github.com/samcontesse/bitbucket-cascade-merge@v0.0.0-20230227091349-c5ec053235b5/models_test.go (about)

     1  package main
     2  
     3  import (
     4  	"math"
     5  	"reflect"
     6  	"testing"
     7  )
     8  
     9  func TestRepository_URL(t *testing.T) {
    10  	type fields struct {
    11  		Links Links
    12  	}
    13  	type args struct {
    14  		protocols string
    15  	}
    16  	tests := []struct {
    17  		name    string
    18  		fields  fields
    19  		args    args
    20  		want    string
    21  		wantErr bool
    22  	}{
    23  		{
    24  			name: "FindHttps",
    25  			fields: fields{
    26  				Links: Links{
    27  					Clone: []*Link{{
    28  						Name: "https",
    29  						Href: "https://git.com/winterfell.git",
    30  					}},
    31  				},
    32  			},
    33  			args:    args{protocols: "https"},
    34  			want:    "https://git.com/winterfell.git",
    35  			wantErr: false,
    36  		}, {
    37  			name: "FindDefault",
    38  			fields: fields{
    39  				Links: Links{
    40  					Clone: []*Link{{
    41  						Name: "file",
    42  						Href: "/tmp/git/winterfell.git",
    43  					}},
    44  				},
    45  			},
    46  			args:    args{},
    47  			want:    "/tmp/git/winterfell.git",
    48  			wantErr: false,
    49  		}, {
    50  			name: "Missing",
    51  			fields: fields{
    52  				Links: Links{
    53  					Clone: []*Link{{
    54  						Name: "file",
    55  						Href: "/tmp/git/winterfell.git",
    56  					}},
    57  				},
    58  			},
    59  			args:    args{protocols: "https"},
    60  			want:    "",
    61  			wantErr: true,
    62  		},
    63  	}
    64  	for _, tt := range tests {
    65  		t.Run(tt.name, func(t *testing.T) {
    66  			r := &Repository{
    67  				Links: tt.fields.Links,
    68  			}
    69  			got, err := r.URL(tt.args.protocols)
    70  			if (err != nil) != tt.wantErr {
    71  				t.Errorf("URL() error = %v, wantErr %v", err, tt.wantErr)
    72  				return
    73  			}
    74  			if !reflect.DeepEqual(got, tt.want) {
    75  				t.Errorf("URL() got = %v, want %v", got, tt.want)
    76  			}
    77  		})
    78  	}
    79  }
    80  
    81  func TestCascade_Next(t *testing.T) {
    82  	type fields struct {
    83  		Branches []string
    84  		Current  int
    85  	}
    86  	tests := []struct {
    87  		name   string
    88  		fields fields
    89  		want   string
    90  	}{
    91  		{name: "InBound", fields: fields{Branches: []string{"release/2", "release/3"}, Current: 0}, want: "release/3"},
    92  		{name: "OutOfBound", fields: fields{Branches: []string{"release/2", "release/3"}, Current: 1}, want: ""},
    93  	}
    94  	for _, tt := range tests {
    95  		t.Run(tt.name, func(t *testing.T) {
    96  			c := &Cascade{
    97  				Branches: tt.fields.Branches,
    98  				Current:  tt.fields.Current,
    99  			}
   100  			if got := c.Next(); got != tt.want {
   101  				t.Errorf("Next() = %v, want %v", got, tt.want)
   102  			}
   103  		})
   104  	}
   105  }
   106  
   107  func TestCascade_Append(t *testing.T) {
   108  	type fields struct {
   109  		BranchNames []string
   110  	}
   111  	tests := []struct {
   112  		name   string
   113  		fields fields
   114  		want   []string
   115  	}{
   116  		{name: "SortNumeric", fields: fields{BranchNames: []string{"release/3", "release/2"}}, want: []string{"release/2", "release/3"}},
   117  		{name: "SortDevelop", fields: fields{BranchNames: []string{"develop", "release/3"}}, want: []string{"release/3", "develop"}},
   118  	}
   119  	for _, tt := range tests {
   120  		t.Run(tt.name, func(t *testing.T) {
   121  			c := &Cascade{
   122  				Branches: make([]string, 0),
   123  				Current:  0,
   124  			}
   125  			for _, n := range tt.fields.BranchNames {
   126  				c.Append(n)
   127  			}
   128  			if !reflect.DeepEqual(c.Branches, tt.want) {
   129  				t.Errorf("Next() = %v, want %v", c.Branches, tt.want)
   130  			}
   131  		})
   132  	}
   133  }
   134  
   135  func TestCascade_Slice(t *testing.T) {
   136  	type fields struct {
   137  		TargetBranch string
   138  		BranchNames  []string
   139  	}
   140  	tests := []struct {
   141  		name   string
   142  		fields fields
   143  		want   []string
   144  	}{
   145  		{name: "Unbound", fields: fields{BranchNames: []string{"release/3", "release/2"}, TargetBranch: "develop"}, want: []string{}},
   146  		{name: "BoundLast", fields: fields{BranchNames: []string{"develop", "release/3"}, TargetBranch: "develop"}, want: []string{"develop"}},
   147  		{name: "BoundFirst", fields: fields{BranchNames: []string{"develop", "release/2", "release/3"}, TargetBranch: "release/2"}, want: []string{"release/2", "release/3", "develop"}},
   148  	}
   149  	for _, tt := range tests {
   150  		t.Run(tt.name, func(t *testing.T) {
   151  			c := &Cascade{
   152  				Branches: make([]string, 0),
   153  				Current:  0,
   154  			}
   155  			for _, n := range tt.fields.BranchNames {
   156  				c.Append(n)
   157  			}
   158  			c.Slice(tt.fields.TargetBranch)
   159  			if !reflect.DeepEqual(c.Branches, tt.want) {
   160  				t.Errorf("Next() = %v, want %v", c.Branches, tt.want)
   161  			}
   162  		})
   163  	}
   164  }
   165  
   166  func Test_extractVersion(t *testing.T) {
   167  	type args struct {
   168  		b string
   169  	}
   170  	tests := []struct {
   171  		name string
   172  		args args
   173  		want int
   174  	}{
   175  		{
   176  			name: "valid int",
   177  			args: args{b: "kind/10"},
   178  			want: 10,
   179  		}, {
   180  			name: "invalid int",
   181  			args: args{b: "kind/not-int"},
   182  			want: math.MaxInt32,
   183  		}, {
   184  			name: "invalid int (float)",
   185  			args: args{b: "kind/10.1"},
   186  			want: math.MaxInt32,
   187  		}, {
   188  			name: "invalid format",
   189  			args: args{b: "invalid format"},
   190  			want: math.MaxInt32,
   191  		},
   192  	}
   193  	for _, tt := range tests {
   194  		t.Run(tt.name, func(t *testing.T) {
   195  			if got := extractVersion(tt.args.b); got != tt.want {
   196  				t.Errorf("extractVersion() = %v, want %v", got, tt.want)
   197  			}
   198  		})
   199  	}
   200  }