crash.software
Projects
Pull Requests
Issues
Builds
grype
Code
Files
Commits
Branches
Tags
Pull Requests
Code Comments
Code Compare
Issues
Builds
Statistics
Child Projects
‹cra.sh›
RESTful API
Projects STRLCPY grype Commits 8220910b
🤬
Revision indexing in progress... (symbol navigation in revisions will be accurate after indexed)
  • ■ ■ ■ ■ ■ ■
    grype/db/v1/store/store_test.go
    1 1  package store
    2 2   
    3 3  import (
    4  - "io/ioutil"
    5  - "os"
    6 4   "testing"
    7 5   "time"
    8 6   
    skipped 18 lines
    27 25  }
    28 26   
    29 27  func TestStore_GetID_SetID(t *testing.T) {
    30  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    31  - if err != nil {
    32  - t.Fatalf("could not create temp file: %+v", err)
    33  - }
    34  - defer os.Remove(dbTempFile.Name())
     28 + dbTempFile := t.TempDir()
    35 29   
    36  - s, err := New(dbTempFile.Name(), true)
     30 + s, err := New(dbTempFile, true)
    37 31   if err != nil {
    38 32   t.Fatalf("could not create store: %+v", err)
    39 33   }
    skipped 31 lines
    71 65  }
    72 66   
    73 67  func TestStore_GetVulnerability_SetVulnerability(t *testing.T) {
    74  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    75  - if err != nil {
    76  - t.Fatalf("could not create temp file: %+v", err)
    77  - }
    78  - defer os.Remove(dbTempFile.Name())
    79  - 
    80  - s, err := New(dbTempFile.Name(), true)
     68 + dbTempFile := t.TempDir()
     69 + s, err := New(dbTempFile, true)
    81 70   if err != nil {
    82 71   t.Fatalf("could not create store: %+v", err)
    83 72   }
    skipped 79 lines
    163 152  }
    164 153   
    165 154  func TestStore_GetVulnerabilityMetadata_SetVulnerabilityMetadata(t *testing.T) {
    166  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    167  - if err != nil {
    168  - t.Fatalf("could not create temp file: %+v", err)
    169  - }
    170  - defer os.Remove(dbTempFile.Name())
     155 + dbTempFile := t.TempDir()
    171 156   
    172  - s, err := New(dbTempFile.Name(), true)
     157 + s, err := New(dbTempFile, true)
    173 158   if err != nil {
    174 159   t.Fatalf("could not create store: %+v", err)
    175 160   }
    skipped 284 lines
    460 445   
    461 446   for _, test := range tests {
    462 447   t.Run(test.name, func(t *testing.T) {
    463  - dbTempDir, err := ioutil.TempDir("", "grype-db-test-store")
    464  - if err != nil {
    465  - t.Fatalf("could not create temp file: %+v", err)
    466  - }
    467  - defer os.RemoveAll(dbTempDir)
     448 + dbTempDir := t.TempDir()
    468 449   
    469 450   s, err := New(dbTempDir, true)
    470 451   if err != nil {
    skipped 44 lines
  • ■ ■ ■ ■ ■ ■
    grype/db/v2/store/store_test.go
    1 1  package store
    2 2   
    3 3  import (
    4  - "io/ioutil"
    5  - "os"
    6 4   "testing"
    7 5   "time"
    8 6   
    skipped 18 lines
    27 25  }
    28 26   
    29 27  func TestStore_GetID_SetID(t *testing.T) {
    30  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    31  - if err != nil {
    32  - t.Fatalf("could not create temp file: %+v", err)
    33  - }
    34  - defer os.Remove(dbTempFile.Name())
     28 + dbTempFile := t.TempDir()
    35 29   
    36  - s, err := New(dbTempFile.Name(), true)
     30 + s, err := New(dbTempFile, true)
    37 31   if err != nil {
    38 32   t.Fatalf("could not create store: %+v", err)
    39 33   }
    skipped 31 lines
    71 65  }
    72 66   
    73 67  func TestStore_GetVulnerability_SetVulnerability(t *testing.T) {
    74  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    75  - if err != nil {
    76  - t.Fatalf("could not create temp file: %+v", err)
    77  - }
    78  - defer os.Remove(dbTempFile.Name())
    79  - 
    80  - s, err := New(dbTempFile.Name(), true)
     68 + dbTempFile := t.TempDir()
     69 + s, err := New(dbTempFile, true)
    81 70   if err != nil {
    82 71   t.Fatalf("could not create store: %+v", err)
    83 72   }
    skipped 79 lines
    163 152  }
    164 153   
    165 154  func TestStore_GetVulnerabilityMetadata_SetVulnerabilityMetadata(t *testing.T) {
    166  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    167  - if err != nil {
    168  - t.Fatalf("could not create temp file: %+v", err)
    169  - }
    170  - defer os.Remove(dbTempFile.Name())
     155 + dbTempFile := t.TempDir()
    171 156   
    172  - s, err := New(dbTempFile.Name(), true)
     157 + s, err := New(dbTempFile, true)
    173 158   if err != nil {
    174 159   t.Fatalf("could not create store: %+v", err)
    175 160   }
    skipped 284 lines
    460 445   
    461 446   for _, test := range tests {
    462 447   t.Run(test.name, func(t *testing.T) {
    463  - dbTempDir, err := ioutil.TempDir("", "grype-db-test-store")
    464  - if err != nil {
    465  - t.Fatalf("could not create temp file: %+v", err)
    466  - }
    467  - defer os.RemoveAll(dbTempDir)
     448 + dbTempDir := t.TempDir()
    468 449   
    469 450   s, err := New(dbTempDir, true)
    470 451   if err != nil {
    skipped 44 lines
  • ■ ■ ■ ■ ■ ■
    grype/db/v3/store/diff_test.go
    1 1  package store
    2 2   
    3 3  import (
    4  - "io/ioutil"
    5 4   "os"
    6 5   "sort"
    7 6   "testing"
    skipped 5 lines
    13 12   
    14 13  func Test_GetAllVulnerabilities(t *testing.T) {
    15 14   //GIVEN
    16  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    17  - if err != nil {
    18  - t.Fatalf("could not create temp file: %+v", err)
    19  - }
    20  - defer os.Remove(dbTempFile.Name())
     15 + dbTempFile := t.TempDir()
    21 16   
    22  - s, err := New(dbTempFile.Name(), true)
     17 + s, err := New(dbTempFile, true)
    23 18   if err != nil {
    24 19   t.Fatalf("could not create store: %+v", err)
    25 20   }
    skipped 8 lines
    34 29   
    35 30  func Test_GetAllVulnerabilityMetadata(t *testing.T) {
    36 31   //GIVEN
    37  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    38  - if err != nil {
    39  - t.Fatalf("could not create temp file: %+v", err)
    40  - }
    41  - defer os.Remove(dbTempFile.Name())
     32 + dbTempFile := t.TempDir()
    42 33   
    43  - s, err := New(dbTempFile.Name(), true)
     34 + s, err := New(dbTempFile, true)
    44 35   if err != nil {
    45 36   t.Fatalf("could not create store: %+v", err)
    46 37   }
    skipped 8 lines
    55 46   
    56 47  func Test_Diff_Vulnerabilities(t *testing.T) {
    57 48   //GIVEN
    58  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    59  - if err != nil {
    60  - t.Fatalf("could not create temp file: %+v", err)
    61  - }
    62  - defer os.Remove(dbTempFile.Name())
     49 + dbTempFile := t.TempDir()
    63 50   
    64  - s1, err := New(dbTempFile.Name(), true)
     51 + s1, err := New(dbTempFile, true)
    65 52   if err != nil {
    66 53   t.Fatalf("could not create store: %+v", err)
    67 54   }
    68  - dbTempFile, err = ioutil.TempFile("", "grype-db-test-store")
    69  - if err != nil {
    70  - t.Fatalf("could not create temp file: %+v", err)
    71  - }
    72  - defer os.Remove(dbTempFile.Name())
     55 + dbTempFile = t.TempDir()
     56 + defer os.Remove(dbTempFile)
    73 57   
    74  - s2, err := New(dbTempFile.Name(), true)
     58 + s2, err := New(dbTempFile, true)
    75 59   if err != nil {
    76 60   t.Fatalf("could not create store: %+v", err)
    77 61   }
    skipped 91 lines
    169 153   
    170 154  func Test_Diff_Metadata(t *testing.T) {
    171 155   //GIVEN
    172  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    173  - if err != nil {
    174  - t.Fatalf("could not create temp file: %+v", err)
    175  - }
    176  - defer os.Remove(dbTempFile.Name())
     156 + dbTempFile := t.TempDir()
    177 157   
    178  - s1, err := New(dbTempFile.Name(), true)
     158 + s1, err := New(dbTempFile, true)
    179 159   if err != nil {
    180 160   t.Fatalf("could not create store: %+v", err)
    181 161   }
    182  - dbTempFile, err = ioutil.TempFile("", "grype-db-test-store")
    183  - if err != nil {
    184  - t.Fatalf("could not create temp file: %+v", err)
    185  - }
    186  - defer os.Remove(dbTempFile.Name())
     162 + dbTempFile = t.TempDir()
    187 163   
    188  - s2, err := New(dbTempFile.Name(), true)
     164 + s2, err := New(dbTempFile, true)
    189 165   if err != nil {
    190 166   t.Fatalf("could not create store: %+v", err)
    191 167   }
    skipped 70 lines
  • ■ ■ ■ ■ ■ ■
    grype/db/v3/store/store_test.go
    skipped 1 lines
    2 2   
    3 3  import (
    4 4   "encoding/json"
    5  - "io/ioutil"
    6  - "os"
    7 5   "sort"
    8 6   "testing"
    9 7   "time"
    skipped 20 lines
    30 28  }
    31 29   
    32 30  func TestStore_GetID_SetID(t *testing.T) {
    33  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    34  - if err != nil {
    35  - t.Fatalf("could not create temp file: %+v", err)
    36  - }
    37  - defer os.Remove(dbTempFile.Name())
     31 + dbTempFile := t.TempDir()
    38 32   
    39  - s, err := New(dbTempFile.Name(), true)
     33 + s, err := New(dbTempFile, true)
    40 34   if err != nil {
    41 35   t.Fatalf("could not create store: %+v", err)
    42 36   }
    skipped 30 lines
    73 67  }
    74 68   
    75 69  func TestStore_GetVulnerability_SetVulnerability(t *testing.T) {
    76  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    77  - if err != nil {
    78  - t.Fatalf("could not create temp file: %+v", err)
    79  - }
    80  - defer os.Remove(dbTempFile.Name())
    81  - 
    82  - s, err := New(dbTempFile.Name(), true)
     70 + dbTempFile := t.TempDir()
     71 + s, err := New(dbTempFile, true)
    83 72   if err != nil {
    84 73   t.Fatalf("could not create store: %+v", err)
    85 74   }
    skipped 167 lines
    253 242  }
    254 243   
    255 244  func TestStore_GetVulnerabilityMetadata_SetVulnerabilityMetadata(t *testing.T) {
    256  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    257  - if err != nil {
    258  - t.Fatalf("could not create temp file: %+v", err)
    259  - }
    260  - defer os.Remove(dbTempFile.Name())
     245 + dbTempFile := t.TempDir()
    261 246   
    262  - s, err := New(dbTempFile.Name(), true)
     247 + s, err := New(dbTempFile, true)
    263 248   if err != nil {
    264 249   t.Fatalf("could not create store: %+v", err)
    265 250   }
    skipped 461 lines
    727 712   
    728 713   for _, test := range tests {
    729 714   t.Run(test.name, func(t *testing.T) {
    730  - dbTempDir, err := ioutil.TempDir("", "grype-db-test-store")
    731  - if err != nil {
    732  - t.Fatalf("could not create temp file: %+v", err)
    733  - }
    734  - defer os.RemoveAll(dbTempDir)
    735  - 
     715 + dbTempDir := t.TempDir()
    736 716   s, err := New(dbTempDir, true)
    737 717   if err != nil {
    738 718   t.Fatalf("could not create store: %+v", err)
    skipped 261 lines
    1000 980   }
    1001 981   for _, test := range tests {
    1002 982   t.Run(test.name, func(t *testing.T) {
    1003  - dbTempDir, err := ioutil.TempDir("", "grype-db-test-s")
    1004  - if err != nil {
    1005  - t.Fatalf("could not create temp file: %+v", err)
    1006  - }
    1007  - defer os.RemoveAll(dbTempDir)
     983 + dbTempDir := t.TempDir()
    1008 984   
    1009 985   s, err := New(dbTempDir, true)
    1010 986   if err != nil {
    skipped 22 lines
    1033 1009   
    1034 1010  func Test_DiffStore(t *testing.T) {
    1035 1011   //GIVEN
    1036  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    1037  - if err != nil {
    1038  - t.Fatalf("could not create temp file: %+v", err)
    1039  - }
    1040  - defer os.Remove(dbTempFile.Name())
     1012 + dbTempFile := t.TempDir()
    1041 1013   
    1042  - s1, err := New(dbTempFile.Name(), true)
     1014 + s1, err := New(dbTempFile, true)
    1043 1015   if err != nil {
    1044 1016   t.Fatalf("could not create store: %+v", err)
    1045 1017   }
    1046  - dbTempFile, err = ioutil.TempFile("", "grype-db-test-store")
    1047  - if err != nil {
    1048  - t.Fatalf("could not create temp file: %+v", err)
    1049  - }
    1050  - defer os.Remove(dbTempFile.Name())
     1018 + dbTempFile = t.TempDir()
    1051 1019   
    1052  - s2, err := New(dbTempFile.Name(), true)
     1020 + s2, err := New(dbTempFile, true)
    1053 1021   if err != nil {
    1054 1022   t.Fatalf("could not create store: %+v", err)
    1055 1023   }
    skipped 152 lines
  • ■ ■ ■ ■ ■ ■
    grype/db/v4/store/diff_test.go
    1 1  package store
    2 2   
    3 3  import (
    4  - "io/ioutil"
    5  - "os"
    6 4   "sort"
    7 5   "testing"
    8 6   
    skipped 4 lines
    13 11   
    14 12  func Test_GetAllVulnerabilities(t *testing.T) {
    15 13   //GIVEN
    16  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    17  - if err != nil {
    18  - t.Fatalf("could not create temp file: %+v", err)
    19  - }
    20  - defer os.Remove(dbTempFile.Name())
    21  - 
    22  - s, err := New(dbTempFile.Name(), true)
     14 + dbTempFile := t.TempDir()
     15 + s, err := New(dbTempFile, true)
    23 16   if err != nil {
    24 17   t.Fatalf("could not create store: %+v", err)
    25 18   }
    skipped 8 lines
    34 27   
    35 28  func Test_GetAllVulnerabilityMetadata(t *testing.T) {
    36 29   //GIVEN
    37  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    38  - if err != nil {
    39  - t.Fatalf("could not create temp file: %+v", err)
    40  - }
    41  - defer os.Remove(dbTempFile.Name())
    42  - 
    43  - s, err := New(dbTempFile.Name(), true)
     30 + dbTempFile := t.TempDir()
     31 + s, err := New(dbTempFile, true)
    44 32   if err != nil {
    45 33   t.Fatalf("could not create store: %+v", err)
    46 34   }
    skipped 8 lines
    55 43   
    56 44  func Test_Diff_Vulnerabilities(t *testing.T) {
    57 45   //GIVEN
    58  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    59  - if err != nil {
    60  - t.Fatalf("could not create temp file: %+v", err)
    61  - }
    62  - defer os.Remove(dbTempFile.Name())
     46 + dbTempFile := t.TempDir()
    63 47   
    64  - s1, err := New(dbTempFile.Name(), true)
     48 + s1, err := New(dbTempFile, true)
    65 49   if err != nil {
    66 50   t.Fatalf("could not create store: %+v", err)
    67 51   }
    68  - dbTempFile, err = ioutil.TempFile("", "grype-db-test-store")
    69  - if err != nil {
    70  - t.Fatalf("could not create temp file: %+v", err)
    71  - }
    72  - defer os.Remove(dbTempFile.Name())
    73  - 
    74  - s2, err := New(dbTempFile.Name(), true)
     52 + dbTempFile = t.TempDir()
     53 + s2, err := New(dbTempFile, true)
    75 54   if err != nil {
    76 55   t.Fatalf("could not create store: %+v", err)
    77 56   }
    skipped 91 lines
    169 148   
    170 149  func Test_Diff_Metadata(t *testing.T) {
    171 150   //GIVEN
    172  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    173  - if err != nil {
    174  - t.Fatalf("could not create temp file: %+v", err)
    175  - }
    176  - defer os.Remove(dbTempFile.Name())
     151 + dbTempFile := t.TempDir()
    177 152   
    178  - s1, err := New(dbTempFile.Name(), true)
     153 + s1, err := New(dbTempFile, true)
    179 154   if err != nil {
    180 155   t.Fatalf("could not create store: %+v", err)
    181 156   }
    182  - dbTempFile, err = ioutil.TempFile("", "grype-db-test-store")
    183  - if err != nil {
    184  - t.Fatalf("could not create temp file: %+v", err)
    185  - }
    186  - defer os.Remove(dbTempFile.Name())
     157 + dbTempFile = t.TempDir()
    187 158   
    188  - s2, err := New(dbTempFile.Name(), true)
     159 + s2, err := New(dbTempFile, true)
    189 160   if err != nil {
    190 161   t.Fatalf("could not create store: %+v", err)
    191 162   }
    skipped 70 lines
  • ■ ■ ■ ■ ■ ■
    grype/db/v4/store/store_test.go
    skipped 1 lines
    2 2   
    3 3  import (
    4 4   "encoding/json"
    5  - "io/ioutil"
    6  - "os"
    7 5   "sort"
    8 6   "testing"
    9 7   "time"
    skipped 20 lines
    30 28  }
    31 29   
    32 30  func TestStore_GetID_SetID(t *testing.T) {
    33  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    34  - if err != nil {
    35  - t.Fatalf("could not create temp file: %+v", err)
    36  - }
    37  - defer os.Remove(dbTempFile.Name())
     31 + dbTempFile := t.TempDir()
    38 32   
    39  - s, err := New(dbTempFile.Name(), true)
     33 + s, err := New(dbTempFile, true)
    40 34   if err != nil {
    41 35   t.Fatalf("could not create store: %+v", err)
    42 36   }
    skipped 30 lines
    73 67  }
    74 68   
    75 69  func TestStore_GetVulnerability_SetVulnerability(t *testing.T) {
    76  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    77  - if err != nil {
    78  - t.Fatalf("could not create temp file: %+v", err)
    79  - }
    80  - defer os.Remove(dbTempFile.Name())
     70 + dbTempFile := t.TempDir()
    81 71   
    82  - s, err := New(dbTempFile.Name(), true)
     72 + s, err := New(dbTempFile, true)
    83 73   if err != nil {
    84 74   t.Fatalf("could not create store: %+v", err)
    85 75   }
    skipped 194 lines
    280 270  }
    281 271   
    282 272  func TestStore_GetVulnerabilityMetadata_SetVulnerabilityMetadata(t *testing.T) {
    283  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    284  - if err != nil {
    285  - t.Fatalf("could not create temp file: %+v", err)
    286  - }
    287  - defer os.Remove(dbTempFile.Name())
     273 + dbTempFile := t.TempDir()
    288 274   
    289  - s, err := New(dbTempFile.Name(), true)
     275 + s, err := New(dbTempFile, true)
    290 276   if err != nil {
    291 277   t.Fatalf("could not create store: %+v", err)
    292 278   }
    skipped 461 lines
    754 740   
    755 741   for _, test := range tests {
    756 742   t.Run(test.name, func(t *testing.T) {
    757  - dbTempDir, err := ioutil.TempDir("", "grype-db-test-store")
    758  - if err != nil {
    759  - t.Fatalf("could not create temp file: %+v", err)
    760  - }
    761  - defer os.RemoveAll(dbTempDir)
    762  - 
     743 + dbTempDir := t.TempDir()
    763 744   s, err := New(dbTempDir, true)
    764 745   if err != nil {
    765 746   t.Fatalf("could not create store: %+v", err)
    skipped 261 lines
    1027 1008   }
    1028 1009   for _, test := range tests {
    1029 1010   t.Run(test.name, func(t *testing.T) {
    1030  - dbTempDir, err := ioutil.TempDir("", "grype-db-test-s")
    1031  - if err != nil {
    1032  - t.Fatalf("could not create temp file: %+v", err)
    1033  - }
    1034  - defer os.RemoveAll(dbTempDir)
     1011 + dbTempDir := t.TempDir()
    1035 1012   
    1036 1013   s, err := New(dbTempDir, true)
    1037 1014   if err != nil {
    skipped 40 lines
    1078 1055  }
    1079 1056   
    1080 1057  func TestStore_GetVulnerabilityMatchExclusion_SetVulnerabilityMatchExclusion(t *testing.T) {
    1081  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    1082  - if err != nil {
    1083  - t.Fatalf("could not create temp file: %+v", err)
    1084  - }
    1085  - defer os.Remove(dbTempFile.Name())
     1058 + dbTempFile := t.TempDir()
    1086 1059   
    1087  - s, err := New(dbTempFile.Name(), true)
     1060 + s, err := New(dbTempFile, true)
    1088 1061   if err != nil {
    1089 1062   t.Fatalf("could not create store: %+v", err)
    1090 1063   }
    skipped 148 lines
    1239 1212   
    1240 1213  func Test_DiffStore(t *testing.T) {
    1241 1214   //GIVEN
    1242  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    1243  - if err != nil {
    1244  - t.Fatalf("could not create temp file: %+v", err)
    1245  - }
    1246  - defer os.Remove(dbTempFile.Name())
     1215 + dbTempFile := t.TempDir()
    1247 1216   
    1248  - s1, err := New(dbTempFile.Name(), true)
     1217 + s1, err := New(dbTempFile, true)
    1249 1218   if err != nil {
    1250 1219   t.Fatalf("could not create store: %+v", err)
    1251 1220   }
    1252  - dbTempFile, err = ioutil.TempFile("", "grype-db-test-store")
    1253  - if err != nil {
    1254  - t.Fatalf("could not create temp file: %+v", err)
    1255  - }
    1256  - defer os.Remove(dbTempFile.Name())
     1221 + dbTempFile = t.TempDir()
    1257 1222   
    1258  - s2, err := New(dbTempFile.Name(), true)
     1223 + s2, err := New(dbTempFile, true)
    1259 1224   if err != nil {
    1260 1225   t.Fatalf("could not create store: %+v", err)
    1261 1226   }
    skipped 152 lines
  • ■ ■ ■ ■ ■ ■
    grype/db/v5/store/diff_test.go
    1 1  package store
    2 2   
    3 3  import (
    4  - "io/ioutil"
    5 4   "os"
    6 5   "sort"
    7 6   "testing"
    skipped 5 lines
    13 12   
    14 13  func Test_GetAllVulnerabilities(t *testing.T) {
    15 14   //GIVEN
    16  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    17  - if err != nil {
    18  - t.Fatalf("could not create temp file: %+v", err)
    19  - }
    20  - defer os.Remove(dbTempFile.Name())
     15 + dbTempFile := t.TempDir()
    21 16   
    22  - s, err := New(dbTempFile.Name(), true)
     17 + s, err := New(dbTempFile, true)
    23 18   if err != nil {
    24 19   t.Fatalf("could not create store: %+v", err)
    25 20   }
    skipped 8 lines
    34 29   
    35 30  func Test_GetAllVulnerabilityMetadata(t *testing.T) {
    36 31   //GIVEN
    37  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    38  - if err != nil {
    39  - t.Fatalf("could not create temp file: %+v", err)
    40  - }
    41  - defer os.Remove(dbTempFile.Name())
     32 + dbTempFile := t.TempDir()
     33 + 
     34 + defer os.Remove(dbTempFile)
    42 35   
    43  - s, err := New(dbTempFile.Name(), true)
     36 + s, err := New(dbTempFile, true)
    44 37   if err != nil {
    45 38   t.Fatalf("could not create store: %+v", err)
    46 39   }
    skipped 8 lines
    55 48   
    56 49  func Test_Diff_Vulnerabilities(t *testing.T) {
    57 50   //GIVEN
    58  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    59  - if err != nil {
    60  - t.Fatalf("could not create temp file: %+v", err)
    61  - }
    62  - defer os.Remove(dbTempFile.Name())
     51 + dbTempFile := t.TempDir()
    63 52   
    64  - s1, err := New(dbTempFile.Name(), true)
     53 + s1, err := New(dbTempFile, true)
    65 54   if err != nil {
    66 55   t.Fatalf("could not create store: %+v", err)
    67 56   }
    68  - dbTempFile, err = ioutil.TempFile("", "grype-db-test-store")
    69  - if err != nil {
    70  - t.Fatalf("could not create temp file: %+v", err)
    71  - }
    72  - defer os.Remove(dbTempFile.Name())
     57 + dbTempFile = t.TempDir()
    73 58   
    74  - s2, err := New(dbTempFile.Name(), true)
     59 + s2, err := New(dbTempFile, true)
    75 60   if err != nil {
    76 61   t.Fatalf("could not create store: %+v", err)
    77 62   }
    skipped 91 lines
    169 154   
    170 155  func Test_Diff_Metadata(t *testing.T) {
    171 156   //GIVEN
    172  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    173  - if err != nil {
    174  - t.Fatalf("could not create temp file: %+v", err)
    175  - }
    176  - defer os.Remove(dbTempFile.Name())
    177  - 
    178  - s1, err := New(dbTempFile.Name(), true)
     157 + dbTempFile := t.TempDir()
     158 + s1, err := New(dbTempFile, true)
    179 159   if err != nil {
    180 160   t.Fatalf("could not create store: %+v", err)
    181 161   }
    182  - dbTempFile, err = ioutil.TempFile("", "grype-db-test-store")
    183  - if err != nil {
    184  - t.Fatalf("could not create temp file: %+v", err)
    185  - }
    186  - defer os.Remove(dbTempFile.Name())
    187  - 
    188  - s2, err := New(dbTempFile.Name(), true)
     162 + dbTempFile = t.TempDir()
     163 + s2, err := New(dbTempFile, true)
    189 164   if err != nil {
    190 165   t.Fatalf("could not create store: %+v", err)
    191 166   }
    skipped 70 lines
  • ■ ■ ■ ■ ■ ■
    grype/db/v5/store/store_test.go
    skipped 1 lines
    2 2   
    3 3  import (
    4 4   "encoding/json"
    5  - "io/ioutil"
    6  - "os"
    7 5   "sort"
    8 6   "testing"
    9 7   "time"
    skipped 20 lines
    30 28  }
    31 29   
    32 30  func TestStore_GetID_SetID(t *testing.T) {
    33  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    34  - if err != nil {
    35  - t.Fatalf("could not create temp file: %+v", err)
    36  - }
    37  - defer os.Remove(dbTempFile.Name())
     31 + dbTempFile := t.TempDir()
    38 32   
    39  - s, err := New(dbTempFile.Name(), true)
     33 + s, err := New(dbTempFile, true)
    40 34   if err != nil {
    41 35   t.Fatalf("could not create store: %+v", err)
    42 36   }
    skipped 30 lines
    73 67  }
    74 68   
    75 69  func TestStore_GetVulnerability_SetVulnerability(t *testing.T) {
    76  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    77  - if err != nil {
    78  - t.Fatalf("could not create temp file: %+v", err)
    79  - }
    80  - defer os.Remove(dbTempFile.Name())
    81  - 
    82  - s, err := New(dbTempFile.Name(), true)
     70 + dbTempFile := t.TempDir()
     71 + s, err := New(dbTempFile, true)
    83 72   if err != nil {
    84 73   t.Fatalf("could not create store: %+v", err)
    85 74   }
    skipped 194 lines
    280 269  }
    281 270   
    282 271  func TestStore_GetVulnerabilityMetadata_SetVulnerabilityMetadata(t *testing.T) {
    283  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    284  - if err != nil {
    285  - t.Fatalf("could not create temp file: %+v", err)
    286  - }
    287  - defer os.Remove(dbTempFile.Name())
     272 + dbTempFile := t.TempDir()
    288 273   
    289  - s, err := New(dbTempFile.Name(), true)
     274 + s, err := New(dbTempFile, true)
    290 275   if err != nil {
    291 276   t.Fatalf("could not create store: %+v", err)
    292 277   }
    skipped 461 lines
    754 739   
    755 740   for _, test := range tests {
    756 741   t.Run(test.name, func(t *testing.T) {
    757  - dbTempDir, err := ioutil.TempDir("", "grype-db-test-store")
    758  - if err != nil {
    759  - t.Fatalf("could not create temp file: %+v", err)
    760  - }
    761  - defer os.RemoveAll(dbTempDir)
     742 + dbTempDir := t.TempDir()
    762 743   
    763 744   s, err := New(dbTempDir, true)
    764 745   if err != nil {
    skipped 262 lines
    1027 1008   }
    1028 1009   for _, test := range tests {
    1029 1010   t.Run(test.name, func(t *testing.T) {
    1030  - dbTempDir, err := ioutil.TempDir("", "grype-db-test-s")
    1031  - if err != nil {
    1032  - t.Fatalf("could not create temp file: %+v", err)
    1033  - }
    1034  - defer os.RemoveAll(dbTempDir)
     1011 + dbTempDir := t.TempDir()
    1035 1012   
    1036 1013   s, err := New(dbTempDir, true)
    1037 1014   if err != nil {
    skipped 40 lines
    1078 1055  }
    1079 1056   
    1080 1057  func TestStore_GetVulnerabilityMatchExclusion_SetVulnerabilityMatchExclusion(t *testing.T) {
    1081  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    1082  - if err != nil {
    1083  - t.Fatalf("could not create temp file: %+v", err)
    1084  - }
    1085  - defer os.Remove(dbTempFile.Name())
     1058 + dbTempFile := t.TempDir()
    1086 1059   
    1087  - s, err := New(dbTempFile.Name(), true)
     1060 + s, err := New(dbTempFile, true)
    1088 1061   if err != nil {
    1089 1062   t.Fatalf("could not create store: %+v", err)
    1090 1063   }
    skipped 148 lines
    1239 1212   
    1240 1213  func Test_DiffStore(t *testing.T) {
    1241 1214   //GIVEN
    1242  - dbTempFile, err := ioutil.TempFile("", "grype-db-test-store")
    1243  - if err != nil {
    1244  - t.Fatalf("could not create temp file: %+v", err)
    1245  - }
    1246  - defer os.Remove(dbTempFile.Name())
    1247  - 
    1248  - s1, err := New(dbTempFile.Name(), true)
     1215 + dbTempFile := t.TempDir()
     1216 + s1, err := New(dbTempFile, true)
    1249 1217   if err != nil {
    1250 1218   t.Fatalf("could not create store: %+v", err)
    1251 1219   }
    1252  - dbTempFile, err = ioutil.TempFile("", "grype-db-test-store")
    1253  - if err != nil {
    1254  - t.Fatalf("could not create temp file: %+v", err)
    1255  - }
    1256  - defer os.Remove(dbTempFile.Name())
    1257  - 
    1258  - s2, err := New(dbTempFile.Name(), true)
     1220 + dbTempFile = t.TempDir()
     1221 + s2, err := New(dbTempFile, true)
    1259 1222   if err != nil {
    1260 1223   t.Fatalf("could not create store: %+v", err)
    1261 1224   }
    skipped 152 lines
Please wait...
Page is in error, reload to recover