github.com/yoctocloud/packer@v0.6.2-0.20160520224004-e11a0a18423f/packer/ui_test.go (about) 1 package packer 2 3 import ( 4 "bytes" 5 "os" 6 "strings" 7 "testing" 8 ) 9 10 // This reads the output from the bytes.Buffer in our test object 11 // and then resets the buffer. 12 func readWriter(ui *BasicUi) (result string) { 13 buffer := ui.Writer.(*bytes.Buffer) 14 result = buffer.String() 15 buffer.Reset() 16 return 17 } 18 19 func readErrorWriter(ui *BasicUi) (result string) { 20 buffer := ui.ErrorWriter.(*bytes.Buffer) 21 result = buffer.String() 22 buffer.Reset() 23 return 24 } 25 26 func testUi() *BasicUi { 27 return &BasicUi{ 28 Reader: new(bytes.Buffer), 29 Writer: new(bytes.Buffer), 30 ErrorWriter: new(bytes.Buffer), 31 } 32 } 33 34 func TestColoredUi(t *testing.T) { 35 bufferUi := testUi() 36 ui := &ColoredUi{UiColorYellow, UiColorRed, bufferUi} 37 38 if !ui.supportsColors() { 39 t.Skip("skipping for ui without color support") 40 } 41 42 ui.Say("foo") 43 result := readWriter(bufferUi) 44 if result != "\033[1;33mfoo\033[0m\n" { 45 t.Fatalf("invalid output: %s", result) 46 } 47 48 ui.Message("foo") 49 result = readWriter(bufferUi) 50 if result != "\033[0;33mfoo\033[0m\n" { 51 t.Fatalf("invalid output: %s", result) 52 } 53 54 ui.Error("foo") 55 result = readWriter(bufferUi) 56 if result != "" { 57 t.Fatalf("invalid output: %s", result) 58 } 59 60 result = readErrorWriter(bufferUi) 61 if result != "\033[1;31mfoo\033[0m\n" { 62 t.Fatalf("invalid output: %s", result) 63 } 64 } 65 66 func TestColoredUi_noColorEnv(t *testing.T) { 67 bufferUi := testUi() 68 ui := &ColoredUi{UiColorYellow, UiColorRed, bufferUi} 69 70 // Set the env var to get rid of the color 71 oldenv := os.Getenv("PACKER_NO_COLOR") 72 os.Setenv("PACKER_NO_COLOR", "1") 73 defer os.Setenv("PACKER_NO_COLOR", oldenv) 74 75 ui.Say("foo") 76 result := readWriter(bufferUi) 77 if result != "foo\n" { 78 t.Fatalf("invalid output: %s", result) 79 } 80 81 ui.Message("foo") 82 result = readWriter(bufferUi) 83 if result != "foo\n" { 84 t.Fatalf("invalid output: %s", result) 85 } 86 87 ui.Error("foo") 88 result = readErrorWriter(bufferUi) 89 if result != "foo\n" { 90 t.Fatalf("invalid output: %s", result) 91 } 92 } 93 94 func TestTargettedUi(t *testing.T) { 95 bufferUi := testUi() 96 targettedUi := &TargettedUi{ 97 Target: "foo", 98 Ui: bufferUi, 99 } 100 101 var actual, expected string 102 targettedUi.Say("foo") 103 actual = readWriter(bufferUi) 104 expected = "==> foo: foo\n" 105 if actual != expected { 106 t.Fatalf("bad: %#v", actual) 107 } 108 109 targettedUi.Message("foo") 110 actual = readWriter(bufferUi) 111 expected = " foo: foo\n" 112 if actual != expected { 113 t.Fatalf("bad: %#v", actual) 114 } 115 116 targettedUi.Error("bar") 117 actual = readErrorWriter(bufferUi) 118 expected = "==> foo: bar\n" 119 if actual != expected { 120 t.Fatalf("bad: %#v", actual) 121 } 122 123 targettedUi.Say("foo\nbar") 124 actual = readWriter(bufferUi) 125 expected = "==> foo: foo\n==> foo: bar\n" 126 if actual != expected { 127 t.Fatalf("bad: %#v", actual) 128 } 129 } 130 131 func TestColoredUi_ImplUi(t *testing.T) { 132 var raw interface{} 133 raw = &ColoredUi{} 134 if _, ok := raw.(Ui); !ok { 135 t.Fatalf("ColoredUi must implement Ui") 136 } 137 } 138 139 func TestTargettedUi_ImplUi(t *testing.T) { 140 var raw interface{} 141 raw = &TargettedUi{} 142 if _, ok := raw.(Ui); !ok { 143 t.Fatalf("TargettedUi must implement Ui") 144 } 145 } 146 147 func TestBasicUi_ImplUi(t *testing.T) { 148 var raw interface{} 149 raw = &BasicUi{} 150 if _, ok := raw.(Ui); !ok { 151 t.Fatalf("BasicUi must implement Ui") 152 } 153 } 154 155 func TestBasicUi_Error(t *testing.T) { 156 bufferUi := testUi() 157 158 var actual, expected string 159 bufferUi.Error("foo") 160 actual = readErrorWriter(bufferUi) 161 expected = "foo\n" 162 if actual != expected { 163 t.Fatalf("bad: %#v", actual) 164 } 165 166 bufferUi.ErrorWriter = nil 167 bufferUi.Error("5") 168 actual = readWriter(bufferUi) 169 expected = "5\n" 170 if actual != expected { 171 t.Fatalf("bad: %#v", actual) 172 } 173 } 174 175 func TestBasicUi_Say(t *testing.T) { 176 bufferUi := testUi() 177 178 var actual, expected string 179 180 bufferUi.Say("foo") 181 actual = readWriter(bufferUi) 182 expected = "foo\n" 183 if actual != expected { 184 t.Fatalf("bad: %#v", actual) 185 } 186 187 bufferUi.Say("5") 188 actual = readWriter(bufferUi) 189 expected = "5\n" 190 if actual != expected { 191 t.Fatalf("bad: %#v", actual) 192 } 193 } 194 195 func TestMachineReadableUi_ImplUi(t *testing.T) { 196 var raw interface{} 197 raw = &MachineReadableUi{} 198 if _, ok := raw.(Ui); !ok { 199 t.Fatalf("MachineReadableUi must implement Ui") 200 } 201 } 202 203 func TestMachineReadableUi(t *testing.T) { 204 var data, expected string 205 206 buf := new(bytes.Buffer) 207 ui := &MachineReadableUi{Writer: buf} 208 209 // No target 210 ui.Machine("foo", "bar", "baz") 211 data = strings.SplitN(buf.String(), ",", 2)[1] 212 expected = ",foo,bar,baz\n" 213 if data != expected { 214 t.Fatalf("bad: %s", data) 215 } 216 217 // Target 218 buf.Reset() 219 ui.Machine("mitchellh,foo", "bar", "baz") 220 data = strings.SplitN(buf.String(), ",", 2)[1] 221 expected = "mitchellh,foo,bar,baz\n" 222 if data != expected { 223 t.Fatalf("bad: %s", data) 224 } 225 226 // Commas 227 buf.Reset() 228 ui.Machine("foo", "foo,bar") 229 data = strings.SplitN(buf.String(), ",", 2)[1] 230 expected = ",foo,foo%!(PACKER_COMMA)bar\n" 231 if data != expected { 232 t.Fatalf("bad: %s", data) 233 } 234 235 // New lines 236 buf.Reset() 237 ui.Machine("foo", "foo\n") 238 data = strings.SplitN(buf.String(), ",", 2)[1] 239 expected = ",foo,foo\\n\n" 240 if data != expected { 241 t.Fatalf("bad: %#v", data) 242 } 243 }