github.com/hazelops/ize@v1.1.12-0.20230915191306-97d7c0e48f11/internal/manager/alias/alias_test.go (about)

     1  package alias
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/hazelops/ize/internal/config"
     7  	"github.com/hazelops/ize/pkg/terminal"
     8  )
     9  
    10  func TestManager_Build(t *testing.T) {
    11  	type fields struct {
    12  		Project *config.Project
    13  		App     *config.Alias
    14  	}
    15  	type args struct {
    16  		ui terminal.UI
    17  	}
    18  	tests := []struct {
    19  		name    string
    20  		fields  fields
    21  		args    args
    22  		wantErr bool
    23  	}{
    24  		{name: "success", fields: fields{
    25  			Project: &config.Project{},
    26  			App: &config.Alias{
    27  				Name:      "test",
    28  				Icon:      "!",
    29  				DependsOn: nil,
    30  			},
    31  		}, args: args{ui: terminal.ConsoleUI(nil, false)}, wantErr: false},
    32  	}
    33  	for _, tt := range tests {
    34  		t.Run(tt.name, func(t *testing.T) {
    35  			a := &Manager{
    36  				Project: tt.fields.Project,
    37  				App:     tt.fields.App,
    38  			}
    39  			if err := a.Build(tt.args.ui); (err != nil) != tt.wantErr {
    40  				t.Errorf("Build() error = %v, wantErr %v", err, tt.wantErr)
    41  			}
    42  		})
    43  	}
    44  }
    45  
    46  func TestManager_Deploy(t *testing.T) {
    47  	type fields struct {
    48  		Project *config.Project
    49  		App     *config.Alias
    50  	}
    51  	type args struct {
    52  		ui terminal.UI
    53  	}
    54  	tests := []struct {
    55  		name    string
    56  		fields  fields
    57  		args    args
    58  		wantErr bool
    59  	}{
    60  		{name: "success", fields: fields{
    61  			Project: &config.Project{},
    62  			App: &config.Alias{
    63  				Name:      "test",
    64  				Icon:      "!",
    65  				DependsOn: nil,
    66  			},
    67  		}, args: args{ui: terminal.ConsoleUI(nil, false)}, wantErr: false},
    68  	}
    69  	for _, tt := range tests {
    70  		t.Run(tt.name, func(t *testing.T) {
    71  			a := &Manager{
    72  				Project: tt.fields.Project,
    73  				App:     tt.fields.App,
    74  			}
    75  			if err := a.Deploy(tt.args.ui); (err != nil) != tt.wantErr {
    76  				t.Errorf("Deploy() error = %v, wantErr %v", err, tt.wantErr)
    77  			}
    78  		})
    79  	}
    80  }
    81  
    82  func TestManager_Destroy(t *testing.T) {
    83  	type fields struct {
    84  		Project *config.Project
    85  		App     *config.Alias
    86  	}
    87  	type args struct {
    88  		ui terminal.UI
    89  	}
    90  	tests := []struct {
    91  		name    string
    92  		fields  fields
    93  		args    args
    94  		wantErr bool
    95  	}{
    96  		{name: "success", fields: fields{
    97  			Project: &config.Project{},
    98  			App: &config.Alias{
    99  				Name:      "test",
   100  				Icon:      "!",
   101  				DependsOn: nil,
   102  			},
   103  		}, args: args{ui: terminal.ConsoleUI(nil, false)}, wantErr: false},
   104  	}
   105  	for _, tt := range tests {
   106  		t.Run(tt.name, func(t *testing.T) {
   107  			a := &Manager{
   108  				Project: tt.fields.Project,
   109  				App:     tt.fields.App,
   110  			}
   111  			if err := a.Destroy(tt.args.ui, true); (err != nil) != tt.wantErr {
   112  				t.Errorf("Destroy() error = %v, wantErr %v", err, tt.wantErr)
   113  			}
   114  		})
   115  	}
   116  }
   117  
   118  func TestManager_Push(t *testing.T) {
   119  	type fields struct {
   120  		Project *config.Project
   121  		App     *config.Alias
   122  	}
   123  	type args struct {
   124  		ui terminal.UI
   125  	}
   126  	tests := []struct {
   127  		name    string
   128  		fields  fields
   129  		args    args
   130  		wantErr bool
   131  	}{
   132  		{name: "success", fields: fields{
   133  			Project: &config.Project{},
   134  			App: &config.Alias{
   135  				Name:      "test",
   136  				Icon:      "!",
   137  				DependsOn: nil,
   138  			},
   139  		}, args: args{ui: terminal.ConsoleUI(nil, false)}, wantErr: false},
   140  	}
   141  	for _, tt := range tests {
   142  		t.Run(tt.name, func(t *testing.T) {
   143  			a := &Manager{
   144  				Project: tt.fields.Project,
   145  				App:     tt.fields.App,
   146  			}
   147  			if err := a.Push(tt.args.ui); (err != nil) != tt.wantErr {
   148  				t.Errorf("Push() error = %v, wantErr %v", err, tt.wantErr)
   149  			}
   150  		})
   151  	}
   152  }
   153  
   154  func TestManager_Redeploy(t *testing.T) {
   155  	type fields struct {
   156  		Project *config.Project
   157  		App     *config.Alias
   158  	}
   159  	type args struct {
   160  		ui terminal.UI
   161  	}
   162  	tests := []struct {
   163  		name    string
   164  		fields  fields
   165  		args    args
   166  		wantErr bool
   167  	}{
   168  		{name: "success", fields: fields{
   169  			Project: &config.Project{},
   170  			App: &config.Alias{
   171  				Name:      "test",
   172  				Icon:      "!",
   173  				DependsOn: nil,
   174  			},
   175  		}, args: args{ui: terminal.ConsoleUI(nil, false)}, wantErr: false},
   176  	}
   177  	for _, tt := range tests {
   178  		t.Run(tt.name, func(t *testing.T) {
   179  			a := &Manager{
   180  				Project: tt.fields.Project,
   181  				App:     tt.fields.App,
   182  			}
   183  			if err := a.Redeploy(tt.args.ui); (err != nil) != tt.wantErr {
   184  				t.Errorf("Redeploy() error = %v, wantErr %v", err, tt.wantErr)
   185  			}
   186  		})
   187  	}
   188  }