gitee.com/mirrors/gauge@v1.0.6/conn/network_test.go (about) 1 // Copyright 2015 ThoughtWorks, Inc. 2 3 // This file is part of Gauge. 4 5 // Gauge is free software: you can redistribute it and/or modify 6 // it under the terms of the GNU General Public License as published by 7 // the Free Software Foundation, either version 3 of the License, or 8 // (at your option) any later version. 9 10 // Gauge is distributed in the hope that it will be useful, 11 // but WITHOUT ANY WARRANTY; without even the implied warranty of 12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 // GNU General Public License for more details. 14 15 // You should have received a copy of the GNU General Public License 16 // along with Gauge. If not, see <http://www.gnu.org/licenses/>. 17 18 package conn 19 20 import ( 21 "errors" 22 "fmt" 23 "net" 24 "reflect" 25 "testing" 26 "time" 27 28 "github.com/getgauge/gauge/gauge_messages" 29 "github.com/golang/protobuf/proto" 30 ) 31 32 var id int64 33 34 type mockConn struct { 35 sleepDuration time.Duration 36 } 37 38 var responseMessage *gauge_messages.Message 39 40 func (m mockConn) Read(b []byte) (n int, err error) { 41 time.Sleep(m.sleepDuration) 42 if responseMessage.MessageId == 0 { 43 responseMessage.MessageId = id 44 } 45 messageBytes, err := proto.Marshal(responseMessage) 46 data := append(proto.EncodeVarint(uint64(len(messageBytes))), messageBytes...) 47 for i := 0; i < len(data); i++ { 48 b[i] = data[i] 49 } 50 return len(data), nil 51 } 52 53 func (m mockConn) Write(b []byte) (n int, err error) { 54 message := &gauge_messages.Message{} 55 messageLength, bytesRead := proto.DecodeVarint(b) 56 b = b[bytesRead : messageLength+uint64(bytesRead)] 57 proto.Unmarshal(b, message) 58 if id == 0 { 59 id = message.MessageId 60 } 61 return 0, nil 62 } 63 64 func (m mockConn) Close() error { 65 return nil 66 } 67 68 func (m mockConn) LocalAddr() net.Addr { 69 return nil 70 } 71 72 func (m mockConn) RemoteAddr() net.Addr { 73 return nil 74 } 75 76 func (m mockConn) SetDeadline(t time.Time) error { 77 return nil 78 } 79 80 func (m mockConn) SetReadDeadline(t time.Time) error { 81 return nil 82 } 83 84 func (m mockConn) SetWriteDeadline(t time.Time) error { 85 return nil 86 } 87 88 func TestGetResponseForGaugeMessageWithTimeout(t *testing.T) { 89 id = 0 90 responseMessage = &gauge_messages.Message{} 91 message := &gauge_messages.Message{ 92 MessageType: gauge_messages.Message_StepNameRequest, 93 StepNameRequest: &gauge_messages.StepNameRequest{ 94 StepValue: "The worrd {} has {} vowels.", 95 }, 96 } 97 98 responseMessage = &gauge_messages.Message{ 99 MessageType: gauge_messages.Message_StepNameResponse, 100 StepNameResponse: &gauge_messages.StepNameResponse{ 101 FileName: "foo.js", 102 HasAlias: false, 103 IsStepPresent: true, 104 Span: &gauge_messages.Span{Start: 2, End: 6, StartChar: 0, EndChar: 2}, 105 StepName: []string{"The word {} has {} vowels."}, 106 }, 107 } 108 109 conn := mockConn{} 110 111 res, err := GetResponseForMessageWithTimeout(message, conn, 3*time.Second) 112 113 if err != nil { 114 t.Errorf("expected err to be nil. got %v", err) 115 } 116 if !proto.Equal(res, responseMessage) { 117 t.Errorf("expected : %v\ngot : %v", responseMessage, res) 118 } 119 } 120 121 func TestGetResponseForGaugeMessageShoudGiveTheRightResponse(t *testing.T) { 122 id = 1234 123 r := response{ 124 err: make(chan error), 125 result: make(chan *gauge_messages.Message), 126 } 127 128 m.put(id, r) 129 130 message := &gauge_messages.Message{ 131 MessageType: gauge_messages.Message_StepNameRequest, 132 StepNameRequest: &gauge_messages.StepNameRequest{ 133 StepValue: "The worrd {} has {} vowels.", 134 }, 135 } 136 137 responseMessage = &gauge_messages.Message{ 138 MessageType: gauge_messages.Message_StepNameResponse, 139 StepNameResponse: &gauge_messages.StepNameResponse{ 140 FileName: "foo.js", 141 HasAlias: false, 142 IsStepPresent: true, 143 Span: &gauge_messages.Span{Start: 2, End: 2, StartChar: 0, EndChar: 2}, 144 StepName: []string{"The word {} has {} vowels."}, 145 }, 146 } 147 148 conn := mockConn{} 149 150 go getResponseForGaugeMessage(message, conn, response{}, 3*time.Second) 151 152 response := <-r.result 153 if !proto.Equal(response, responseMessage) { 154 t.Errorf("expected : %v\ngot : %v", responseMessage, response) 155 } 156 } 157 158 func TestGetResponseForGaugeMessageShoudGiveErrorForUnsupportedMessage(t *testing.T) { 159 id = 0 160 message := &gauge_messages.Message{ 161 MessageType: gauge_messages.Message_StepNameRequest, 162 StepNameRequest: &gauge_messages.StepNameRequest{ 163 StepValue: "The worrd {} has {} vowels.", 164 }, 165 } 166 167 responseMessage = &gauge_messages.Message{ 168 MessageType: gauge_messages.Message_UnsupportedMessageResponse, 169 UnsupportedMessageResponse: &gauge_messages.UnsupportedMessageResponse{}, 170 } 171 172 conn := mockConn{} 173 174 _, err := GetResponseForMessageWithTimeout(message, conn, 1*time.Second) 175 176 expected := errors.New("Unsupported Message response received. Message not supported.") 177 178 if reflect.DeepEqual(err, expected) { 179 t.Errorf("expected %v\n got %v", expected, err) 180 } 181 182 } 183 184 func TestGetResponseForGaugeMessageShoudErrorWithTimeOut(t *testing.T) { 185 id = 0 186 message := &gauge_messages.Message{ 187 MessageType: gauge_messages.Message_StepNameRequest, 188 StepNameRequest: &gauge_messages.StepNameRequest{ 189 StepValue: "The worrd {} has {} vowels.", 190 }, 191 } 192 193 responseMessage = &gauge_messages.Message{ 194 MessageType: gauge_messages.Message_StepNameResponse, 195 StepNameResponse: &gauge_messages.StepNameResponse{ 196 FileName: "foo.js", 197 HasAlias: false, 198 IsStepPresent: true, 199 Span: &gauge_messages.Span{Start: 2, End: 2, StartChar: 0, EndChar: 2}, 200 StepName: []string{"The word {} has {} vowels."}, 201 }, 202 } 203 204 conn := mockConn{sleepDuration: 2 * time.Second} 205 _, err := GetResponseForMessageWithTimeout(message, conn, 1*time.Second) 206 207 expected := fmt.Errorf("Request timed out for Message with ID => %v and Type => StepNameRequest", id) 208 if !reflect.DeepEqual(err, expected) { 209 t.Errorf("expected %v\n got %v", expected, err) 210 } 211 } 212 213 func TestGetResponseForGaugeMessageShoudNotErrorIfNoTimeoutIsSpecified(t *testing.T) { 214 id = 0 215 message := &gauge_messages.Message{ 216 MessageType: gauge_messages.Message_StepNameRequest, 217 StepNameRequest: &gauge_messages.StepNameRequest{ 218 StepValue: "The worrd {} has {} vowels.", 219 }, 220 } 221 222 responseMessage = &gauge_messages.Message{ 223 MessageType: gauge_messages.Message_StepNameResponse, 224 StepNameResponse: &gauge_messages.StepNameResponse{ 225 FileName: "foo.js", 226 HasAlias: false, 227 IsStepPresent: true, 228 Span: &gauge_messages.Span{Start: 2, End: 6, StartChar: 0, EndChar: 2}, 229 StepName: []string{"The word {} has {} vowels."}, 230 }, 231 } 232 233 conn := mockConn{} 234 235 res, err := GetResponseForMessageWithTimeout(message, conn, 0) 236 237 if err != nil { 238 t.Errorf("expected err to be nil. got %v", err) 239 } 240 if !proto.Equal(res, responseMessage) { 241 t.Errorf("expected : %v\ngot : %v", responseMessage, res) 242 } 243 }