vitess.io/vitess@v0.16.2/go/vt/vtctl/fakevtctlclient/fake_loggerevent_streamingclient_test.go (about) 1 /* 2 Copyright 2019 The Vitess 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 fakevtctlclient 18 19 import ( 20 "errors" 21 "io" 22 "reflect" 23 "strings" 24 "testing" 25 26 logutilpb "vitess.io/vitess/go/vt/proto/logutil" 27 ) 28 29 func TestStreamOutputAndError(t *testing.T) { 30 fake := NewFakeLoggerEventStreamingClient() 31 args := []string{"CopySchemaShard", "test_keyspace/0", "test_keyspace/2"} 32 output := []string{"event1", "event2"} 33 wantErr := errors.New("something went wrong") 34 35 err := fake.RegisterResult(args, strings.Join(output, "\n"), wantErr) 36 if err != nil { 37 t.Fatalf("Failed to register fake result for: %v err: %v", args, err) 38 } 39 40 verifyStreamOutputAndError(t, fake, "" /* addr */, args, output, wantErr) 41 } 42 43 func TestStreamOutput(t *testing.T) { 44 fake := NewFakeLoggerEventStreamingClient() 45 args := []string{"CopySchemaShard", "test_keyspace/0", "test_keyspace/2"} 46 output := []string{"event1", "event2"} 47 var wantErr error 48 49 err := fake.RegisterResult(args, strings.Join(output, "\n"), wantErr) 50 if err != nil { 51 t.Fatalf("Failed to register fake result for: %v err: %v", args, err) 52 } 53 54 verifyStreamOutputAndError(t, fake, "" /* addr */, args, output, wantErr) 55 } 56 57 // TestStreamOutputForAddr is similar to TestStreamOutput but also tests that 58 // the correct server address was used by the client. 59 func TestStreamOutputForAddr(t *testing.T) { 60 fake := NewFakeLoggerEventStreamingClient() 61 addr := "localhost:12345" 62 args := []string{"CopySchemaShard", "test_keyspace/0", "test_keyspace/2"} 63 output := []string{"event1", "event2"} 64 var wantErr error 65 66 // Used address matches. 67 err := fake.RegisterResultForAddr(addr, args, strings.Join(output, "\n"), wantErr) 68 if err != nil { 69 t.Fatalf("Failed to register fake result for: %v err: %v", args, err) 70 } 71 verifyStreamOutputAndError(t, fake, addr, args, output, wantErr) 72 73 // Used address does not match. 74 err = fake.RegisterResultForAddr(addr, args, strings.Join(output, "\n"), wantErr) 75 if err != nil { 76 t.Fatalf("Failed to register fake result for: %v err: %v", args, err) 77 } 78 _, err = fake.StreamResult("different-addr", args) 79 if err == nil || !strings.Contains(err.Error(), "client sent request to wrong server address") { 80 t.Fatalf("fake should have failed because the client used the wrong address: %v", err) 81 } 82 } 83 84 func verifyStreamOutputAndError(t *testing.T, fake *FakeLoggerEventStreamingClient, addr string, args, output []string, wantErr error) { 85 stream, err := fake.StreamResult(addr, args) 86 if err != nil { 87 t.Fatalf("Failed to stream result: %v", err) 88 } 89 90 // Verify output and error. 91 i := 0 92 for { 93 var event *logutilpb.Event 94 event, err = stream.Recv() 95 if err != nil { 96 break 97 } 98 if i > len(output) { 99 t.Fatalf("Received more events than expected. got: %v want: %v", i, len(output)) 100 } 101 if event.Value != output[i] { 102 t.Errorf("Received event is not identical to the received one. got: %v want: %v", event.Value, output[i]) 103 } 104 t.Logf("Received event: %v", event) 105 i++ 106 } 107 if i != len(output) { 108 t.Errorf("Number of received events mismatches. got: %v want: %v", i, len(output)) 109 } 110 if err == io.EOF { 111 err = nil 112 } 113 if err != wantErr { 114 t.Errorf("Wrong error received. got: %v want: %v", err, wantErr) 115 } 116 } 117 118 func TestNoResultRegistered(t *testing.T) { 119 fake := NewFakeLoggerEventStreamingClient() 120 stream, err := fake.StreamResult("" /* addr */, []string{"ListShardTablets", "test_keyspace/0"}) 121 if stream != nil { 122 t.Fatalf("No stream should have been returned because no matching result is registered.") 123 } 124 wantErr := "no response was registered for args: [ListShardTablets test_keyspace/0]" 125 if err.Error() != wantErr { 126 t.Errorf("Wrong error for missing result was returned. got: '%v' want: '%v'", err, wantErr) 127 } 128 } 129 130 func TestResultAlreadyRegistered(t *testing.T) { 131 fake := NewFakeLoggerEventStreamingClient() 132 errFirst := fake.RegisterResult([]string{"ListShardTablets", "test_keyspace/0"}, "output1", nil) 133 if errFirst != nil { 134 t.Fatalf("Registering the result should have been successful. Error: %v", errFirst) 135 } 136 137 errSecond := fake.RegisterResult([]string{"ListShardTablets", "test_keyspace/0"}, "output2", nil) 138 if errSecond == nil { 139 t.Fatal("Registering a duplicate, different result should not have been successful.") 140 } 141 want := ") is already registered for command: " 142 if !strings.Contains(errSecond.Error(), want) { 143 t.Fatalf("Wrong error message: got: '%v' want: '%v'", errSecond, want) 144 } 145 } 146 147 func TestRegisterMultipleResultsForSameCommand(t *testing.T) { 148 fake := NewFakeLoggerEventStreamingClient() 149 args := []string{"CopySchemaShard", "test_keyspace/0", "test_keyspace/2"} 150 output := []string{"event1", "event2"} 151 var wantErr error 152 153 // Register first result. 154 err := fake.RegisterResult(args, strings.Join(output, "\n"), wantErr) 155 if err != nil { 156 t.Fatalf("Failed to register fake result for: %v err: %v", args, err) 157 } 158 registeredCommands := []string{strings.Join(args, " ")} 159 verifyListOfRegisteredCommands(t, fake, registeredCommands) 160 161 // Register second result. 162 err = fake.RegisterResult(args, strings.Join(output, "\n"), wantErr) 163 if err != nil { 164 t.Fatalf("Failed to register fake result for: %v err: %v", args, err) 165 } 166 verifyListOfRegisteredCommands(t, fake, registeredCommands) 167 168 // Consume first result. 169 verifyStreamOutputAndError(t, fake, "" /* addr */, args, output, wantErr) 170 verifyListOfRegisteredCommands(t, fake, registeredCommands) 171 172 // Consume second result. 173 verifyStreamOutputAndError(t, fake, "" /* addr */, args, output, wantErr) 174 verifyListOfRegisteredCommands(t, fake, []string{}) 175 } 176 177 func verifyListOfRegisteredCommands(t *testing.T, fake *FakeLoggerEventStreamingClient, want []string) { 178 got := fake.RegisteredCommands() 179 if len(got) == 0 && len(want) == 0 { 180 return 181 } 182 if !reflect.DeepEqual(got, want) { 183 t.Fatalf("fake.RegisteredCommands() = %v, want: %v", got, want) 184 } 185 }