github.com/markusbkk/elvish@v0.0.0-20231204143114-91dc52438621/pkg/store/storetest/cmd.go (about)

     1  package storetest
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  
     7  	"github.com/markusbkk/elvish/pkg/store/storedefs"
     8  )
     9  
    10  var (
    11  	cmds     = []string{"echo foo", "put bar", "put lorem", "echo bar"}
    12  	searches = []struct {
    13  		next      bool
    14  		seq       int
    15  		prefix    string
    16  		wantedSeq int
    17  		wantedCmd string
    18  		wantedErr error
    19  	}{
    20  		{false, 5, "echo", 4, "echo bar", nil},
    21  		{false, 5, "put", 3, "put lorem", nil},
    22  		{false, 4, "echo", 1, "echo foo", nil},
    23  		{false, 3, "f", 0, "", storedefs.ErrNoMatchingCmd},
    24  		{false, 1, "", 0, "", storedefs.ErrNoMatchingCmd},
    25  
    26  		{true, 1, "echo", 1, "echo foo", nil},
    27  		{true, 1, "put", 2, "put bar", nil},
    28  		{true, 2, "echo", 4, "echo bar", nil},
    29  		{true, 4, "put", 0, "", storedefs.ErrNoMatchingCmd},
    30  	}
    31  )
    32  
    33  // TestCmd tests the command history functionality of a Store.
    34  func TestCmd(t *testing.T, store storedefs.Store) {
    35  	startSeq, err := store.NextCmdSeq()
    36  	if startSeq != 1 || err != nil {
    37  		t.Errorf("store.NextCmdSeq() => (%v, %v), want (1, nil)",
    38  			startSeq, err)
    39  	}
    40  
    41  	// AddCmd
    42  	for i, cmd := range cmds {
    43  		wantSeq := startSeq + i
    44  		seq, err := store.AddCmd(cmd)
    45  		if seq != wantSeq || err != nil {
    46  			t.Errorf("store.AddCmd(%v) => (%v, %v), want (%v, nil)",
    47  				cmd, seq, err, wantSeq)
    48  		}
    49  	}
    50  
    51  	endSeq, err := store.NextCmdSeq()
    52  	wantedEndSeq := startSeq + len(cmds)
    53  	if endSeq != wantedEndSeq || err != nil {
    54  		t.Errorf("store.NextCmdSeq() => (%v, %v), want (%v, nil)",
    55  			endSeq, err, wantedEndSeq)
    56  	}
    57  
    58  	// CmdsWithSeq
    59  	wantCmdWithSeqs := make([]storedefs.Cmd, len(cmds))
    60  	for i, cmd := range cmds {
    61  		wantCmdWithSeqs[i] = storedefs.Cmd{Text: cmd, Seq: i + 1}
    62  	}
    63  	for i := 0; i < len(cmds); i++ {
    64  		for j := i; j <= len(cmds); j++ {
    65  			cmdWithSeqs, err := store.CmdsWithSeq(i+1, j+1)
    66  			if !equalCmds(cmdWithSeqs, wantCmdWithSeqs[i:j]) || err != nil {
    67  				t.Errorf("store.CmdsWithSeq(%v, %v) -> (%v, %v), want (%v, nil)",
    68  					i+1, j+1, cmdWithSeqs, err, wantCmdWithSeqs[i:j])
    69  			}
    70  		}
    71  	}
    72  
    73  	// Cmd
    74  	for i, wantedCmd := range cmds {
    75  		seq := i + startSeq
    76  		cmd, err := store.Cmd(seq)
    77  		if cmd != wantedCmd || err != nil {
    78  			t.Errorf("store.Cmd(%v) => (%v, %v), want (%v, nil)",
    79  				seq, cmd, err, wantedCmd)
    80  		}
    81  	}
    82  
    83  	// PrevCmd and NextCmd
    84  	for _, tt := range searches {
    85  		f := store.PrevCmd
    86  		funcname := "store.PrevCmd"
    87  		if tt.next {
    88  			f = store.NextCmd
    89  			funcname = "store.NextCmd"
    90  		}
    91  		cmd, err := f(tt.seq, tt.prefix)
    92  		wantedCmd := storedefs.Cmd{Text: tt.wantedCmd, Seq: tt.wantedSeq}
    93  		if cmd != wantedCmd || !matchErr(err, tt.wantedErr) {
    94  			t.Errorf("%s(%v, %v) => (%v, %v), want (%v, %v)",
    95  				funcname, tt.seq, tt.prefix, cmd, err, wantedCmd, tt.wantedErr)
    96  		}
    97  	}
    98  
    99  	// DelCmd
   100  	if err := store.DelCmd(1); err != nil {
   101  		t.Error("Failed to remove cmd")
   102  	}
   103  	if seq, err := store.Cmd(1); !matchErr(err, storedefs.ErrNoMatchingCmd) {
   104  		t.Errorf("Cmd(1) => (%v, %v), want (%v, %v)",
   105  			seq, err, "", storedefs.ErrNoMatchingCmd)
   106  	}
   107  }
   108  
   109  func equalCmds(a, b []storedefs.Cmd) bool {
   110  	return (len(a) == 0 && len(b) == 0) || reflect.DeepEqual(a, b)
   111  }