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  }