github.com/treeverse/lakefs@v1.24.1-0.20240520134607-95648127bfb0/pkg/graveler/ref/parse_ref_test.go (about)

     1  package ref_test
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/treeverse/lakefs/pkg/graveler"
     8  	"github.com/treeverse/lakefs/pkg/graveler/ref"
     9  )
    10  
    11  func TestParseRef(t *testing.T) {
    12  	table := []struct {
    13  		Name        string
    14  		Input       string
    15  		Expected    graveler.RawRef
    16  		ExpectedErr error
    17  	}{
    18  		{
    19  			Name:  "just_branch",
    20  			Input: "main",
    21  			Expected: graveler.RawRef{
    22  				BaseRef:   "main",
    23  				Modifiers: make([]graveler.RefModifier, 0),
    24  			},
    25  		},
    26  		{
    27  			Name:  "branch_one_caret",
    28  			Input: "main^",
    29  			Expected: graveler.RawRef{
    30  				BaseRef: "main",
    31  				Modifiers: []graveler.RefModifier{
    32  					{
    33  						Type:  graveler.RefModTypeCaret,
    34  						Value: 1,
    35  					},
    36  				},
    37  			},
    38  		},
    39  		{
    40  			Name:  "branch_one_dollar",
    41  			Input: "main$",
    42  			Expected: graveler.RawRef{
    43  				BaseRef: "main",
    44  				Modifiers: []graveler.RefModifier{
    45  					{
    46  						Type:  graveler.RefModTypeDollar,
    47  						Value: 1,
    48  					},
    49  				},
    50  			},
    51  		},
    52  		{
    53  			Name:  "branch_one_at",
    54  			Input: "main@",
    55  			Expected: graveler.RawRef{
    56  				BaseRef: "main",
    57  				Modifiers: []graveler.RefModifier{
    58  					{
    59  						Type:  graveler.RefModTypeAt,
    60  						Value: 1,
    61  					},
    62  				},
    63  			},
    64  		},
    65  		{
    66  			Name:        "branch_invalid_at",
    67  			Input:       "main@1",
    68  			ExpectedErr: graveler.ErrInvalidRef,
    69  		},
    70  		{
    71  			Name:  "branch_two_caret",
    72  			Input: "main^^",
    73  			Expected: graveler.RawRef{
    74  				BaseRef: "main",
    75  				Modifiers: []graveler.RefModifier{
    76  					{
    77  						Type:  graveler.RefModTypeCaret,
    78  						Value: 1,
    79  					},
    80  					{
    81  						Type:  graveler.RefModTypeCaret,
    82  						Value: 1,
    83  					},
    84  				},
    85  			},
    86  		},
    87  		{
    88  			Name:  "branch_two_caret_one_qualified",
    89  			Input: "main^2^",
    90  			Expected: graveler.RawRef{
    91  				BaseRef: "main",
    92  				Modifiers: []graveler.RefModifier{
    93  					{
    94  						Type:  graveler.RefModTypeCaret,
    95  						Value: 2,
    96  					},
    97  					{
    98  						Type:  graveler.RefModTypeCaret,
    99  						Value: 1,
   100  					},
   101  				},
   102  			},
   103  		},
   104  		{
   105  			Name:  "branch_tilde_caret_tilde",
   106  			Input: "main~^~3",
   107  			Expected: graveler.RawRef{
   108  				BaseRef: "main",
   109  				Modifiers: []graveler.RefModifier{
   110  					{
   111  						Type:  graveler.RefModTypeTilde,
   112  						Value: 1,
   113  					},
   114  					{
   115  						Type:  graveler.RefModTypeCaret,
   116  						Value: 1,
   117  					},
   118  					{
   119  						Type:  graveler.RefModTypeTilde,
   120  						Value: 3,
   121  					},
   122  				},
   123  			},
   124  		},
   125  		{
   126  			Name:        "no_base",
   127  			Input:       "^^^3",
   128  			ExpectedErr: graveler.ErrInvalidRef,
   129  		},
   130  		{
   131  			Name:        "non_numeric_qualifier",
   132  			Input:       "main^a",
   133  			ExpectedErr: graveler.ErrInvalidRef,
   134  		},
   135  	}
   136  
   137  	for _, cas := range table {
   138  		t.Run(cas.Name, func(t *testing.T) {
   139  			got, err := ref.ParseRef(graveler.Ref(cas.Input))
   140  			if cas.ExpectedErr != nil {
   141  				if !errors.Is(err, cas.ExpectedErr) {
   142  					t.Fatalf("expected error of type: %s, got %v", cas.ExpectedErr, err)
   143  				}
   144  				return
   145  			} else if err != nil {
   146  				t.Fatalf("unexpected error: %v", err)
   147  			}
   148  
   149  			if got.BaseRef != cas.Expected.BaseRef {
   150  				t.Fatalf("expected base rev: %s got %s", cas.Expected.BaseRef, got.BaseRef)
   151  			}
   152  
   153  			if len(got.Modifiers) != len(cas.Expected.Modifiers) {
   154  				t.Fatalf("got wrong number of modifiers, expected %d got %d",
   155  					len(cas.Expected.Modifiers), len(got.Modifiers))
   156  			}
   157  
   158  			for i, m := range got.Modifiers {
   159  				if m.Type != cas.Expected.Modifiers[i].Type {
   160  					t.Fatalf("unexpected modifier at index %d: expected type %d got %d",
   161  						i, cas.Expected.Modifiers[i].Type, m.Type)
   162  				}
   163  				if m.Value != cas.Expected.Modifiers[i].Value {
   164  					t.Fatalf("unexpected modifier at index %d: expected value %d got %d",
   165  						i, cas.Expected.Modifiers[i].Value, m.Value)
   166  				}
   167  			}
   168  		})
   169  	}
   170  }