github.com/maxgio92/test-infra@v0.1.0/kubetest/main_test.go (about) 1 /* 2 Copyright 2017 The Kubernetes Authors. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package main 18 19 import ( 20 "encoding/json" 21 "fmt" 22 "os" 23 "path/filepath" 24 "strconv" 25 "strings" 26 "testing" 27 28 "github.com/maxgio92/test-infra/kubetest/util" 29 ) 30 31 func TestWriteMetadata(t *testing.T) { 32 type mdata map[string]string 33 cases := []struct { 34 sources map[string]mdata 35 key string 36 version string 37 }{ 38 { 39 sources: nil, 40 key: "job-version", 41 version: "v1.8.0-alpha.2.251+ba2bdb1aead615", 42 }, 43 { 44 sources: nil, 45 key: "revision", 46 version: "v1.8.0-alpha.2.251+ba2bdb1aead615", 47 }, 48 { 49 sources: map[string]mdata{"images.json": {"imgkey": "imgval"}}, 50 key: "imgkey", 51 version: "v1.8.0-alpha.2.251+ba2bdb1aead615", 52 }, 53 { 54 sources: map[string]mdata{ 55 "images.json": {"imgkey": "imgval"}, 56 "foo.json": {"fookey": "fooval"}, 57 }, 58 key: "fookey", 59 version: "v1.8.0-alpha.2.251+ba2bdb1aead615", 60 }, 61 } 62 63 writeTmpMetadataSource := func(filePath string, md mdata) { 64 outputBytes, _ := json.MarshalIndent(md, "", " ") 65 if err := os.WriteFile(filePath, outputBytes, 0644); err != nil { 66 t.Fatalf("write to %q: %v", filePath, err) 67 } 68 } 69 70 for _, tc := range cases { 71 topDir := t.TempDir() 72 73 dumpDir := filepath.Join(topDir, "artifacts") 74 if err := os.Mkdir(dumpDir, 0755); err != nil { 75 t.Fatal(err) 76 } 77 78 if err := os.WriteFile(filepath.Join(topDir, "version"), []byte(tc.version+"\n"), 0644); err != nil { 79 t.Fatalf("write %q/version: %v", topDir, err) 80 } 81 sourceNames := []string{} 82 for filename, metadata := range tc.sources { 83 sourceNames = append(sourceNames, filename) 84 writeTmpMetadataSource(filepath.Join(dumpDir, filename), metadata) 85 } 86 87 // Now we've set things up, call the function 88 // 89 os.Chdir(topDir) // version file is read from "." 90 writeMetadata(dumpDir, strings.Join(sourceNames, ",")) 91 92 // Load up the output 93 metadata := map[string]string{} 94 maybeMergeJSON(metadata, filepath.Join(dumpDir, "metadata.json")) 95 96 if _, exists := metadata[tc.key]; !exists { 97 t.Errorf("Expcected metadata key %q, but read in map %#v\n", tc.key, metadata) 98 } 99 } 100 } 101 102 func TestMigrateGcpEnvAndOptions(t *testing.T) { 103 proj := "fake-project" 104 zone := "fake-zone" 105 cases := []struct { 106 name string 107 provider string 108 expectedArg string 109 }{ 110 { 111 name: "gce sets KUBE_GCE_ZONE", 112 provider: "gce", 113 expectedArg: "KUBE_GCE_ZONE", 114 }, 115 { 116 name: "gke sets ZONE", 117 provider: "gke", 118 expectedArg: "ZONE", 119 }, 120 { 121 name: "random provider sets KUBE_GCE_ZONE", 122 provider: "random", 123 expectedArg: "KUBE_GCE_ZONE", 124 }, 125 } 126 127 // Preserve original ZONE, KUBE_GCE_ZONE state 128 if pz, err := util.PushEnv("ZONE", "unset"); err != nil { 129 t.Fatalf("Could not set ZONE: %v", err) 130 } else { 131 defer pz() 132 } 133 if pkgz, err := util.PushEnv("KUBE_GCE_ZONE", "unset"); err != nil { 134 t.Fatalf("Could not set KUBE_GCE_ZONE: %v", err) 135 } else { 136 defer pkgz() 137 } 138 139 for _, tc := range cases { 140 if err := os.Unsetenv("KUBE_GCE_ZONE"); err != nil { 141 t.Fatalf("%s: could not unset KUBE_GCE_ZONE", tc.name) 142 } 143 if err := os.Unsetenv("ZONE"); err != nil { 144 t.Fatalf("%s: could not unset ZONE", tc.name) 145 } 146 o := options{ 147 gcpProject: proj, 148 gcpZone: zone, 149 provider: tc.provider, 150 } 151 if err := migrateGcpEnvAndOptions(&o); err != nil { 152 t.Errorf("%s: failed to migrate: %v", tc.name, err) 153 } 154 155 z := os.Getenv(tc.expectedArg) 156 if z != zone { 157 t.Errorf("%s: %s is '%s' not expected '%s'", tc.name, tc.expectedArg, z, zone) 158 } 159 } 160 } 161 162 func TestPrepareParallelism(t *testing.T) { 163 cases := []struct { 164 initial []string 165 ginkgoParallel string 166 ginkgoParallelNodes string 167 wantParallel int 168 }{ 169 { 170 wantParallel: 1, 171 }, 172 { 173 initial: []string{"10"}, 174 wantParallel: 10, 175 }, 176 { 177 initial: []string{"true"}, 178 wantParallel: defaultGinkgoParallel, 179 }, 180 { 181 initial: []string{"true", "20"}, 182 wantParallel: 20, 183 }, 184 { 185 ginkgoParallel: "y", 186 wantParallel: defaultGinkgoParallel, 187 }, 188 { 189 ginkgoParallel: "y", 190 ginkgoParallelNodes: "50", 191 wantParallel: 50, 192 }, 193 { 194 ginkgoParallelNodes: "50", 195 wantParallel: 50, 196 }, 197 { 198 initial: []string{"20"}, 199 ginkgoParallelNodes: "50", 200 wantParallel: 50, 201 }, 202 } 203 204 // Preserve original GINKGO_PARALLEL and GINKGO_PARALLEL_NODES 205 if pre, err := util.PushEnv("GINKGO_PARALLEL", "unset"); err != nil { 206 t.Fatalf("Could not set GINKGO_PARALLEL: %v", err) 207 } else { 208 defer pre() 209 } 210 if pre, err := util.PushEnv("GINKGO_PARALLEL_NODES", "unset"); err != nil { 211 t.Fatalf("Could not set GINKGO_PARALLEL_NODES: %v", err) 212 } else { 213 defer pre() 214 } 215 216 for _, tc := range cases { 217 desc := fmt.Sprintf("(%v, %q, %q)", tc.initial, tc.ginkgoParallel, tc.ginkgoParallelNodes) 218 if err := os.Setenv("GINKGO_PARALLEL", tc.ginkgoParallel); err != nil { 219 t.Fatalf("%s => could not unset GINKGO_PARALLEL", desc) 220 } 221 if err := os.Setenv("GINKGO_PARALLEL_NODES", tc.ginkgoParallelNodes); err != nil { 222 t.Fatalf("%s => could not unset GINKGO_PARALLEL_NODES", desc) 223 } 224 v := ginkgoParallelValue{} 225 for _, i := range tc.initial { 226 if err := v.Set(i); err != nil { 227 t.Fatalf("%s => could not .Set(%q): %v", desc, i, err) 228 } 229 } 230 if err := prepareGinkgoParallel(&v); err != nil { 231 t.Errorf("%s => error %v, did not want", desc, err) 232 } 233 234 if i := v.Get(); i != tc.wantParallel { 235 t.Errorf("%s => parallel %d (got) != %d (want)", desc, i, tc.wantParallel) 236 } 237 if gp := os.Getenv("GINKGO_PARALLEL"); gp != "" { 238 t.Errorf("%s => GINKGO_PARALLEL is set to %q, did not want", desc, gp) 239 } 240 if gpn := os.Getenv("GINKGO_PARALLEL_NODES"); gpn != strconv.Itoa(v.Get()) { 241 t.Errorf("%s => GINKGO_PARALLEL_NODES=%s (got) != %s (want)", desc, gpn, v.String()) 242 } 243 } 244 }