github.com/aavshr/aws-sdk-go@v1.41.3/private/protocol/eventstream/shared_test.go (about)

     1  package eventstream
     2  
     3  import (
     4  	"bufio"
     5  	"bytes"
     6  	"encoding/json"
     7  	"fmt"
     8  	"io/ioutil"
     9  	"path/filepath"
    10  	"testing"
    11  )
    12  
    13  type testCase struct {
    14  	Name    string
    15  	Encoded []byte
    16  	Decoded decodedMessage
    17  }
    18  
    19  type testErrorCase struct {
    20  	Name    string
    21  	Encoded []byte
    22  	Err     string
    23  }
    24  
    25  type rawTestCase struct {
    26  	Name             string
    27  	Encoded, Decoded []byte
    28  }
    29  
    30  func readRawTestCases(root, class string) (map[string]rawTestCase, error) {
    31  	encoded, err := readTests(filepath.Join(root, "encoded", class))
    32  	if err != nil {
    33  		return nil, err
    34  	}
    35  
    36  	decoded, err := readTests(filepath.Join(root, "decoded", class))
    37  	if err != nil {
    38  		return nil, err
    39  	}
    40  
    41  	if len(encoded) == 0 {
    42  		return nil, fmt.Errorf("expect encoded cases, found none")
    43  	}
    44  
    45  	if len(encoded) != len(decoded) {
    46  		return nil, fmt.Errorf("encoded and decoded sets different")
    47  	}
    48  
    49  	rawCases := map[string]rawTestCase{}
    50  	for name, encData := range encoded {
    51  		decData, ok := decoded[name]
    52  		if !ok {
    53  			return nil, fmt.Errorf("encoded %q case not found in decoded set", name)
    54  		}
    55  
    56  		rawCases[name] = rawTestCase{
    57  			Name:    name,
    58  			Encoded: encData,
    59  			Decoded: decData,
    60  		}
    61  	}
    62  
    63  	return rawCases, nil
    64  }
    65  
    66  func readNegativeTests(root string) ([]testErrorCase, error) {
    67  	rawCases, err := readRawTestCases(root, "negative")
    68  	if err != nil {
    69  		return nil, err
    70  	}
    71  
    72  	cases := make([]testErrorCase, 0, len(rawCases))
    73  	for name, rawCase := range rawCases {
    74  		cases = append(cases, testErrorCase{
    75  			Name:    name,
    76  			Encoded: rawCase.Encoded,
    77  			Err:     string(rawCase.Decoded),
    78  		})
    79  	}
    80  
    81  	return cases, nil
    82  }
    83  
    84  func readPositiveTests(root string) ([]testCase, error) {
    85  	rawCases, err := readRawTestCases(root, "positive")
    86  	if err != nil {
    87  		return nil, err
    88  	}
    89  
    90  	cases := make([]testCase, 0, len(rawCases))
    91  	for name, rawCase := range rawCases {
    92  
    93  		var dec decodedMessage
    94  		if err := json.Unmarshal(rawCase.Decoded, &dec); err != nil {
    95  			return nil, fmt.Errorf("failed to decode %q, %v", name, err)
    96  		}
    97  
    98  		cases = append(cases, testCase{
    99  			Name:    name,
   100  			Encoded: rawCase.Encoded,
   101  			Decoded: dec,
   102  		})
   103  	}
   104  
   105  	return cases, nil
   106  }
   107  
   108  func readTests(root string) (map[string][]byte, error) {
   109  	items, err := ioutil.ReadDir(root)
   110  	if err != nil {
   111  		return nil, fmt.Errorf("failed to read test suite %q dirs, %v", root, err)
   112  	}
   113  
   114  	cases := map[string][]byte{}
   115  	for _, item := range items {
   116  		if item.IsDir() {
   117  			continue
   118  		}
   119  
   120  		filename := filepath.Join(root, item.Name())
   121  		data, err := ioutil.ReadFile(filename)
   122  		if err != nil {
   123  			return nil, fmt.Errorf("failed to read test_data file %q, %v", filename, err)
   124  		}
   125  
   126  		cases[item.Name()] = data
   127  	}
   128  
   129  	return cases, nil
   130  }
   131  
   132  func compareLines(t *testing.T, a, b []byte) bool {
   133  	as := bufio.NewScanner(bytes.NewBuffer(a))
   134  	bs := bufio.NewScanner(bytes.NewBuffer(b))
   135  
   136  	var failed bool
   137  	for {
   138  		if ab, bb := as.Scan(), bs.Scan(); ab != bb {
   139  			t.Errorf("expect a & b to have same number of lines")
   140  			return false
   141  		} else if !ab {
   142  			break
   143  		}
   144  
   145  		if v1, v2 := as.Text(), bs.Text(); v1 != v2 {
   146  			t.Errorf("expect %q to be %q", v1, v2)
   147  			failed = true
   148  		}
   149  	}
   150  
   151  	return !failed
   152  }