github.com/pingcap/chaos@v0.0.0-20190710112158-c86faf4b3719/pkg/model/register_test.go (about)

     1  package model
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  
     7  	"github.com/anishathalye/porcupine"
     8  )
     9  
    10  func TestRegisterModel(t *testing.T) {
    11  	// Test taken from github.com/anishathalye/porcupine
    12  	// examples taken from http://nil.csail.mit.edu/6.824/2017/quizzes/q2-17-ans.pdf
    13  	// section VII
    14  
    15  	ops := []porcupine.Operation{
    16  		{RegisterRequest{RegisterWrite, 100}, 0, RegisterResponse{false, 0}, 100},
    17  		{RegisterRequest{RegisterRead, 0}, 25, RegisterResponse{false, 100}, 75},
    18  		{RegisterRequest{RegisterRead, 0}, 30, RegisterResponse{false, 0}, 60},
    19  	}
    20  	res := porcupine.CheckOperations(convertModel(RegisterModel()), ops)
    21  	if res != true {
    22  		t.Fatal("expected operations to be linearizable")
    23  	}
    24  
    25  	// same example as above, but with Event
    26  	events := []porcupine.Event{
    27  		{porcupine.CallEvent, RegisterRequest{RegisterWrite, 100}, 0},
    28  		{porcupine.CallEvent, RegisterRequest{RegisterRead, 0}, 1},
    29  		{porcupine.CallEvent, RegisterRequest{RegisterRead, 0}, 2},
    30  		{porcupine.ReturnEvent, RegisterResponse{false, 0}, 2},
    31  		{porcupine.ReturnEvent, RegisterResponse{false, 100}, 1},
    32  		{porcupine.ReturnEvent, RegisterResponse{false, 0}, 0},
    33  	}
    34  	res = porcupine.CheckEvents(convertModel(RegisterModel()), events)
    35  	if res != true {
    36  		t.Fatal("expected operations to be linearizable")
    37  	}
    38  
    39  	ops = []porcupine.Operation{
    40  		{RegisterRequest{RegisterWrite, 200}, 0, RegisterResponse{false, 0}, 100},
    41  		{RegisterRequest{RegisterRead, 0}, 10, RegisterResponse{false, 200}, 30},
    42  		{RegisterRequest{RegisterRead, 0}, 40, RegisterResponse{false, 0}, 90},
    43  	}
    44  	res = porcupine.CheckOperations(convertModel(RegisterModel()), ops)
    45  	if res != false {
    46  		t.Fatal("expected operations to not be linearizable")
    47  	}
    48  
    49  	// same example as above, but with Event
    50  	events = []porcupine.Event{
    51  		{porcupine.CallEvent, RegisterRequest{RegisterWrite, 200}, 0},
    52  		{porcupine.CallEvent, RegisterRequest{RegisterRead, 0}, 1},
    53  		{porcupine.ReturnEvent, RegisterResponse{false, 200}, 1},
    54  		{porcupine.CallEvent, RegisterRequest{RegisterRead, 0}, 2},
    55  		{porcupine.ReturnEvent, RegisterResponse{false, 0}, 2},
    56  		{porcupine.ReturnEvent, RegisterResponse{false, 0}, 0},
    57  	}
    58  	res = porcupine.CheckEvents(convertModel(RegisterModel()), events)
    59  	if res != false {
    60  		t.Fatal("expected operations to not be linearizable")
    61  	}
    62  }
    63  
    64  func TestRegisterModelPrepare(t *testing.T) {
    65  	model := RegisterModel()
    66  	model.Prepare(777)
    67  	state := model.Init()
    68  	if state.(int) != 777 {
    69  		t.Fatalf("expected to be 777, got %v", state)
    70  	}
    71  }
    72  
    73  func TestRegisterParser(t *testing.T) {
    74  	parser := registerParser{}
    75  
    76  	for _, c := range []struct {
    77  		data []byte
    78  		req  RegisterRequest
    79  	}{
    80  		{[]byte(`{"Op":false,"Value":0}`),
    81  			RegisterRequest{RegisterRead, 0}},
    82  		{[]byte(`{"Op":true,"Value":5135627519135374257}`),
    83  			RegisterRequest{RegisterWrite, 5135627519135374257}},
    84  	} {
    85  		raw := json.RawMessage{}
    86  		if err := json.Unmarshal(c.data, &raw); err != nil {
    87  			t.Fatalf("unexpected err: %v, req: %v", err, c.req)
    88  		}
    89  		r, err := parser.OnRequest(raw)
    90  		if err != nil {
    91  			t.Fatalf("unexpected err: %v, req: %v", err, c.req)
    92  		}
    93  		req := r.(RegisterRequest)
    94  		if req.Op != c.req.Op || req.Value != c.req.Value {
    95  			t.Fatalf("expected equal: %v, req: %v", req, c.req)
    96  		}
    97  	}
    98  
    99  	for _, c := range []struct {
   100  		data []byte
   101  		resp RegisterResponse
   102  	}{
   103  		{[]byte(`{"Unknown":false,"Value":0}`),
   104  			RegisterResponse{false, 0}},
   105  		{[]byte(`{"Unknown":false,"Value":5135627519135374257}`),
   106  			RegisterResponse{false, 5135627519135374257}},
   107  		{[]byte(`{"Unknown":true,"Value":7}`),
   108  			RegisterResponse{true, 7}},
   109  	} {
   110  		raw := json.RawMessage{}
   111  		if err := json.Unmarshal(c.data, &raw); err != nil {
   112  			t.Fatalf("unexpected err: %v, resp: %v", err, c.resp)
   113  		}
   114  		r, err := parser.OnResponse(raw)
   115  		if err != nil {
   116  			t.Fatalf("unexpected err: %v, resp: %v", err, c.resp)
   117  		}
   118  		if r != nil {
   119  			resp := r.(RegisterResponse)
   120  			if resp.Value != c.resp.Value || resp.Unknown != c.resp.Unknown {
   121  				t.Fatalf("expected equal: %v != %v", resp, c.resp)
   122  			}
   123  		}
   124  	}
   125  }