github.com/almamedia/fargate@v0.2.4-0.20220704071213-7b5b3d27c5eb/cmd/vpc_operation_test.go (about)

     1  package cmd
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/golang/mock/gomock"
     8  	"github.com/almamedia/fargate/cmd/mock"
     9  	ec2client "github.com/almamedia/fargate/ec2/mock/client"
    10  )
    11  
    12  func TestSetSubnetIDs(t *testing.T) {
    13  	mockCtrl := gomock.NewController(t)
    14  	defer mockCtrl.Finish()
    15  
    16  	mockEC2Client := ec2client.NewMockClient(mockCtrl)
    17  	mockOutput := &mock.Output{}
    18  
    19  	mockEC2Client.EXPECT().GetSubnetVPCID("subnet-1234567").Return("vpc-1234567", nil)
    20  
    21  	operation := vpcOperation{
    22  		ec2:    mockEC2Client,
    23  		output: mockOutput,
    24  	}
    25  
    26  	err := operation.setSubnetIDs([]string{"subnet-1234567"})
    27  
    28  	if err != nil {
    29  		t.Errorf("expected no error, got: %v", err)
    30  	}
    31  
    32  	if len(operation.subnetIDs) != 1 {
    33  		t.Fatalf("expected 1 subnet ID, got: %d", len(operation.subnetIDs))
    34  	}
    35  
    36  	if expected := "subnet-1234567"; operation.subnetIDs[0] != expected {
    37  		t.Errorf("expected: %s, got: %s", expected, operation.subnetIDs[0])
    38  	}
    39  
    40  	if expected := "vpc-1234567"; operation.vpcID != expected {
    41  		t.Errorf("expected: %s, got: %s", expected, operation.vpcID)
    42  	}
    43  }
    44  
    45  func TestSetSubnetIDsError(t *testing.T) {
    46  	mockCtrl := gomock.NewController(t)
    47  	defer mockCtrl.Finish()
    48  
    49  	mockEC2Client := ec2client.NewMockClient(mockCtrl)
    50  	mockOutput := &mock.Output{}
    51  
    52  	mockEC2Client.EXPECT().GetSubnetVPCID("subnet-1234567").Return("", errors.New("boom"))
    53  
    54  	operation := vpcOperation{
    55  		ec2:    mockEC2Client,
    56  		output: mockOutput,
    57  	}
    58  
    59  	err := operation.setSubnetIDs([]string{"subnet-1234567"})
    60  
    61  	if err == nil {
    62  		t.Errorf("expected error, got none")
    63  	}
    64  
    65  	if expected := "boom"; err.Error() != expected {
    66  		t.Errorf("expected: %s, got: %v", expected, err)
    67  	}
    68  }
    69  
    70  func TestSetDefaultSecurityGroupID(t *testing.T) {
    71  	mockCtrl := gomock.NewController(t)
    72  	defer mockCtrl.Finish()
    73  
    74  	mockEC2Client := ec2client.NewMockClient(mockCtrl)
    75  	mockOutput := &mock.Output{}
    76  
    77  	mockEC2Client.EXPECT().GetDefaultSecurityGroupID().Return("sg-1234567", nil)
    78  
    79  	operation := vpcOperation{
    80  		ec2:    mockEC2Client,
    81  		output: mockOutput,
    82  	}
    83  
    84  	err := operation.setDefaultSecurityGroupID()
    85  
    86  	if err != nil {
    87  		t.Errorf("expected no error, got: %v", err)
    88  	}
    89  
    90  	if len(operation.securityGroupIDs) != 1 {
    91  		t.Fatalf("expected 1 security group ID, got: %d", len(operation.securityGroupIDs))
    92  	}
    93  
    94  	if expected := "sg-1234567"; operation.securityGroupIDs[0] != expected {
    95  		t.Errorf("expected: %s, got: %s", expected, operation.securityGroupIDs[0])
    96  	}
    97  }
    98  
    99  func TestSetDefaultSecurityGroupIDLookupError(t *testing.T) {
   100  	mockCtrl := gomock.NewController(t)
   101  	defer mockCtrl.Finish()
   102  
   103  	mockEC2Client := ec2client.NewMockClient(mockCtrl)
   104  	mockOutput := &mock.Output{}
   105  
   106  	mockEC2Client.EXPECT().GetDefaultSecurityGroupID().Return("", errors.New("boom"))
   107  
   108  	operation := vpcOperation{
   109  		ec2:    mockEC2Client,
   110  		output: mockOutput,
   111  	}
   112  
   113  	err := operation.setDefaultSecurityGroupID()
   114  
   115  	if err == nil {
   116  		t.Errorf("expected error, got none")
   117  	}
   118  
   119  	if expected := "boom"; err.Error() != expected {
   120  		t.Errorf("expected: %s, got: %v", expected, err)
   121  	}
   122  }
   123  
   124  func TestSetDefaultSecurityGroupIDWithCreate(t *testing.T) {
   125  	mockCtrl := gomock.NewController(t)
   126  	defer mockCtrl.Finish()
   127  
   128  	mockEC2Client := ec2client.NewMockClient(mockCtrl)
   129  	mockOutput := &mock.Output{}
   130  
   131  	mockEC2Client.EXPECT().GetDefaultSecurityGroupID().Return("", nil)
   132  	mockEC2Client.EXPECT().CreateDefaultSecurityGroup().Return("sg-1234567", nil)
   133  	mockEC2Client.EXPECT().AuthorizeAllSecurityGroupIngress("sg-1234567").Return(nil)
   134  
   135  	operation := vpcOperation{
   136  		ec2:    mockEC2Client,
   137  		output: mockOutput,
   138  	}
   139  
   140  	err := operation.setDefaultSecurityGroupID()
   141  
   142  	if err != nil {
   143  		t.Errorf("expected no error, got: %v", err)
   144  	}
   145  
   146  	if len(operation.securityGroupIDs) != 1 {
   147  		t.Fatalf("expected 1 security group ID, got: %d", len(operation.securityGroupIDs))
   148  	}
   149  
   150  	if expected := "sg-1234567"; operation.securityGroupIDs[0] != expected {
   151  		t.Errorf("expected: %s, got: %s", expected, operation.securityGroupIDs[0])
   152  	}
   153  }
   154  
   155  func TestSetDefaultSecurityGroupIDWithCreateError(t *testing.T) {
   156  	mockCtrl := gomock.NewController(t)
   157  	defer mockCtrl.Finish()
   158  
   159  	mockEC2Client := ec2client.NewMockClient(mockCtrl)
   160  	mockOutput := &mock.Output{}
   161  
   162  	mockEC2Client.EXPECT().GetDefaultSecurityGroupID().Return("", nil)
   163  	mockEC2Client.EXPECT().CreateDefaultSecurityGroup().Return("", errors.New("boom"))
   164  
   165  	operation := vpcOperation{
   166  		ec2:    mockEC2Client,
   167  		output: mockOutput,
   168  	}
   169  
   170  	err := operation.setDefaultSecurityGroupID()
   171  
   172  	if err == nil {
   173  		t.Errorf("expected error, got none")
   174  	}
   175  
   176  	if expected := "boom"; err.Error() != expected {
   177  		t.Errorf("expected: %s, got: %v", expected, err)
   178  	}
   179  }
   180  
   181  func TestSetDefaultSecurityGroupIDWithAuthorizeError(t *testing.T) {
   182  	mockCtrl := gomock.NewController(t)
   183  	defer mockCtrl.Finish()
   184  
   185  	mockEC2Client := ec2client.NewMockClient(mockCtrl)
   186  	mockOutput := &mock.Output{}
   187  
   188  	mockEC2Client.EXPECT().GetDefaultSecurityGroupID().Return("", nil)
   189  	mockEC2Client.EXPECT().CreateDefaultSecurityGroup().Return("sg-1234567", nil)
   190  	mockEC2Client.EXPECT().AuthorizeAllSecurityGroupIngress("sg-1234567").Return(errors.New("boom"))
   191  
   192  	operation := vpcOperation{
   193  		ec2:    mockEC2Client,
   194  		output: mockOutput,
   195  	}
   196  
   197  	err := operation.setDefaultSecurityGroupID()
   198  
   199  	if err == nil {
   200  		t.Errorf("expected error, got none")
   201  	}
   202  
   203  	if expected := "boom"; err.Error() != expected {
   204  		t.Errorf("expected: %s, got: %v", expected, err)
   205  	}
   206  }
   207  
   208  func TestSetDefaultSubnetIDs(t *testing.T) {
   209  	mockCtrl := gomock.NewController(t)
   210  	defer mockCtrl.Finish()
   211  
   212  	mockEC2Client := ec2client.NewMockClient(mockCtrl)
   213  	mockOutput := &mock.Output{}
   214  
   215  	mockEC2Client.EXPECT().GetDefaultSubnetIDs().Return([]string{"subnet-1234567", "subnet-abcdef"}, nil)
   216  	mockEC2Client.EXPECT().GetSubnetVPCID("subnet-1234567").Return("vpc-1234567", nil)
   217  
   218  	operation := vpcOperation{
   219  		ec2:    mockEC2Client,
   220  		output: mockOutput,
   221  	}
   222  
   223  	err := operation.setDefaultSubnetIDs()
   224  
   225  	if err != nil {
   226  		t.Errorf("expected no error, got: %v", err)
   227  	}
   228  
   229  	if len(operation.subnetIDs) != 2 {
   230  		t.Fatalf("expected 2 subnet IDs, got: %d", len(operation.subnetIDs))
   231  	}
   232  
   233  	if expected := "subnet-1234567"; operation.subnetIDs[0] != expected {
   234  		t.Errorf("expected: %s, got: %s", expected, operation.subnetIDs[0])
   235  	}
   236  
   237  	if expected := "vpc-1234567"; operation.vpcID != expected {
   238  		t.Errorf("expected: %s, got: %s", expected, operation.vpcID)
   239  	}
   240  }
   241  
   242  func TestSetDefaultSubnetIDsLookupError(t *testing.T) {
   243  	mockCtrl := gomock.NewController(t)
   244  	defer mockCtrl.Finish()
   245  
   246  	mockEC2Client := ec2client.NewMockClient(mockCtrl)
   247  	mockOutput := &mock.Output{}
   248  
   249  	mockEC2Client.EXPECT().GetDefaultSubnetIDs().Return([]string{}, errors.New("boom"))
   250  
   251  	operation := vpcOperation{
   252  		ec2:    mockEC2Client,
   253  		output: mockOutput,
   254  	}
   255  
   256  	err := operation.setDefaultSubnetIDs()
   257  
   258  	if err == nil {
   259  		t.Errorf("expected error, got none")
   260  	}
   261  
   262  	if expected := "boom"; err.Error() != expected {
   263  		t.Errorf("expected: %s, got: %v", expected, err)
   264  	}
   265  }
   266  
   267  func TestSetDefaultSubnetIDsVPCError(t *testing.T) {
   268  	mockCtrl := gomock.NewController(t)
   269  	defer mockCtrl.Finish()
   270  
   271  	mockEC2Client := ec2client.NewMockClient(mockCtrl)
   272  	mockOutput := &mock.Output{}
   273  
   274  	mockEC2Client.EXPECT().GetDefaultSubnetIDs().Return([]string{"subnet-1234567", "subnet-abcdef"}, nil)
   275  	mockEC2Client.EXPECT().GetSubnetVPCID("subnet-1234567").Return("", errors.New("boom"))
   276  
   277  	operation := vpcOperation{
   278  		ec2:    mockEC2Client,
   279  		output: mockOutput,
   280  	}
   281  
   282  	err := operation.setDefaultSubnetIDs()
   283  
   284  	if err == nil {
   285  		t.Errorf("expected error, got none")
   286  	}
   287  
   288  	if expected := "boom"; err.Error() != expected {
   289  		t.Errorf("expected: %s, got: %v", expected, err)
   290  	}
   291  }