github.com/yrj2011/jx-test-infra@v0.0.0-20190529031832-7a2065ee98eb/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 "io/ioutil" 23 "os" 24 "path/filepath" 25 "strconv" 26 "strings" 27 "testing" 28 29 "k8s.io/test-infra/kubetest/util" 30 ) 31 32 func TestWriteMetadata(t *testing.T) { 33 type mdata map[string]string 34 cases := []struct { 35 sources map[string]mdata 36 key string 37 version string 38 }{ 39 { 40 sources: nil, 41 key: "version", 42 version: "v1.8.0-alpha.2.251+ba2bdb1aead615", 43 }, 44 { 45 sources: map[string]mdata{"images.json": {"imgkey": "imgval"}}, 46 key: "imgkey", 47 version: "v1.8.0-alpha.2.251+ba2bdb1aead615", 48 }, 49 { 50 sources: map[string]mdata{ 51 "images.json": {"imgkey": "imgval"}, 52 "foo.json": {"fookey": "fooval"}, 53 }, 54 key: "fookey", 55 version: "v1.8.0-alpha.2.251+ba2bdb1aead615", 56 }, 57 } 58 59 writeTmpMetadataSource := func(filePath string, md mdata) { 60 outputBytes, _ := json.MarshalIndent(md, "", " ") 61 if err := ioutil.WriteFile(filePath, outputBytes, 0644); err != nil { 62 t.Fatalf("write to %q: %v", filePath, err) 63 } 64 } 65 66 for _, tc := range cases { 67 topDir, err := ioutil.TempDir("", "TestWriteMetadata") 68 69 if err != nil { 70 t.Fatal(err) 71 } 72 73 defer os.RemoveAll(topDir) // Stack up all the cleanups 74 75 dumpDir := filepath.Join(topDir, "artifacts") 76 if err := os.Mkdir(dumpDir, 0755); err != nil { 77 t.Fatal(err) 78 } 79 80 if err := ioutil.WriteFile(filepath.Join(topDir, "version"), []byte(tc.version+"\n"), 0644); err != nil { 81 t.Fatalf("write %q/version: %v", topDir, err) 82 } 83 sourceNames := []string{} 84 for filename, metadata := range tc.sources { 85 sourceNames = append(sourceNames, filename) 86 writeTmpMetadataSource(filepath.Join(dumpDir, filename), metadata) 87 } 88 89 // Now we've set things up, call the function 90 // 91 os.Chdir(topDir) // version file is read from "." 92 writeMetadata(dumpDir, strings.Join(sourceNames, ",")) 93 94 // Load up the output 95 metadata := map[string]string{} 96 maybeMergeJSON(metadata, filepath.Join(dumpDir, "metadata.json")) 97 98 if _, exists := metadata[tc.key]; !exists { 99 t.Errorf("Expcected metadata key %q, but read in map %#v\n", tc.key, metadata) 100 } 101 } 102 } 103 104 func TestMigrateGcpEnvAndOptions(t *testing.T) { 105 proj := "fake-project" 106 zone := "fake-zone" 107 cases := []struct { 108 name string 109 provider string 110 expectedArg string 111 }{ 112 { 113 name: "gce sets KUBE_GCE_ZONE", 114 provider: "gce", 115 expectedArg: "KUBE_GCE_ZONE", 116 }, 117 { 118 name: "gke sets ZONE", 119 provider: "gke", 120 expectedArg: "ZONE", 121 }, 122 { 123 name: "random provider sets KUBE_GCE_ZONE", 124 provider: "random", 125 expectedArg: "KUBE_GCE_ZONE", 126 }, 127 } 128 129 // Preserve original ZONE, KUBE_GCE_ZONE state 130 if pz, err := util.PushEnv("ZONE", "unset"); err != nil { 131 t.Fatalf("Could not set ZONE: %v", err) 132 } else { 133 defer pz() 134 } 135 if pkgz, err := util.PushEnv("KUBE_GCE_ZONE", "unset"); err != nil { 136 t.Fatalf("Could not set KUBE_GCE_ZONE: %v", err) 137 } else { 138 defer pkgz() 139 } 140 141 for _, tc := range cases { 142 if err := os.Unsetenv("KUBE_GCE_ZONE"); err != nil { 143 t.Fatalf("%s: could not unset KUBE_GCE_ZONE", tc.name) 144 } 145 if err := os.Unsetenv("ZONE"); err != nil { 146 t.Fatalf("%s: could not unset ZONE", tc.name) 147 } 148 o := options{ 149 gcpProject: proj, 150 gcpZone: zone, 151 provider: tc.provider, 152 } 153 if err := migrateGcpEnvAndOptions(&o); err != nil { 154 t.Errorf("%s: failed to migrate: %v", tc.name, err) 155 } 156 157 z := os.Getenv(tc.expectedArg) 158 if z != zone { 159 t.Errorf("%s: %s is '%s' not expected '%s'", tc.name, tc.expectedArg, z, zone) 160 } 161 } 162 } 163 164 func TestPrepareParallelism(t *testing.T) { 165 cases := []struct { 166 initial []string 167 ginkgoParallel string 168 ginkgoParallelNodes string 169 wantParallel int 170 }{ 171 { 172 wantParallel: 1, 173 }, 174 { 175 initial: []string{"10"}, 176 wantParallel: 10, 177 }, 178 { 179 initial: []string{"true"}, 180 wantParallel: defaultGinkgoParallel, 181 }, 182 { 183 initial: []string{"true", "20"}, 184 wantParallel: 20, 185 }, 186 { 187 ginkgoParallel: "y", 188 wantParallel: defaultGinkgoParallel, 189 }, 190 { 191 ginkgoParallel: "y", 192 ginkgoParallelNodes: "50", 193 wantParallel: 50, 194 }, 195 { 196 ginkgoParallelNodes: "50", 197 wantParallel: 50, 198 }, 199 { 200 initial: []string{"20"}, 201 ginkgoParallelNodes: "50", 202 wantParallel: 50, 203 }, 204 } 205 206 // Preserve original GINKGO_PARALLEL and GINKGO_PARALLEL_NODES 207 if pre, err := util.PushEnv("GINKGO_PARALLEL", "unset"); err != nil { 208 t.Fatalf("Could not set GINKGO_PARALLEL: %v", err) 209 } else { 210 defer pre() 211 } 212 if pre, err := util.PushEnv("GINKGO_PARALLEL_NODES", "unset"); err != nil { 213 t.Fatalf("Could not set GINKGO_PARALLEL_NODES: %v", err) 214 } else { 215 defer pre() 216 } 217 218 for _, tc := range cases { 219 desc := fmt.Sprintf("(%v, %q, %q)", tc.initial, tc.ginkgoParallel, tc.ginkgoParallelNodes) 220 if err := os.Setenv("GINKGO_PARALLEL", tc.ginkgoParallel); err != nil { 221 t.Fatalf("%s => could not unset GINKGO_PARALLEL", desc) 222 } 223 if err := os.Setenv("GINKGO_PARALLEL_NODES", tc.ginkgoParallelNodes); err != nil { 224 t.Fatalf("%s => could not unset GINKGO_PARALLEL_NODES", desc) 225 } 226 v := ginkgoParallelValue{} 227 for _, i := range tc.initial { 228 if err := v.Set(i); err != nil { 229 t.Fatalf("%s => could not .Set(%q): %v", desc, i, err) 230 } 231 } 232 if err := prepareGinkgoParallel(&v); err != nil { 233 t.Errorf("%s => error %v, did not want", desc, err) 234 } 235 236 if i := v.Get(); i != tc.wantParallel { 237 t.Errorf("%s => parallel %d (got) != %d (want)", desc, i, tc.wantParallel) 238 } 239 if gp := os.Getenv("GINKGO_PARALLEL"); gp != "" { 240 t.Errorf("%s => GINKGO_PARALLEL is set to %q, did not want", desc, gp) 241 } 242 if gpn := os.Getenv("GINKGO_PARALLEL_NODES"); gpn != strconv.Itoa(v.Get()) { 243 t.Errorf("%s => GINKGO_PARALLEL_NODES=%s (got) != %s (want)", desc, gpn, v.String()) 244 } 245 } 246 }