github.com/kyma-project/kyma-environment-broker@v0.0.1/common/hyperscaler/azure/testing/testing.go (about)

     1  package testing
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  
     7  	"github.com/Azure/azure-sdk-for-go/services/eventhub/mgmt/2017-04-01/eventhub"
     8  	"github.com/Azure/azure-sdk-for-go/services/resources/mgmt/2019-05-01/resources"
     9  	"github.com/Azure/go-autorest/autorest"
    10  	"github.com/sirupsen/logrus"
    11  
    12  	"github.com/kyma-project/kyma-environment-broker/common/hyperscaler/azure"
    13  	"github.com/kyma-project/kyma-environment-broker/internal/ptr"
    14  )
    15  
    16  // ensure the fake Client is implementing the interface
    17  var _ azure.Interface = (*FakeNamespaceClient)(nil)
    18  
    19  // / A fake Client for Azure EventHubs Namespace handling
    20  type FakeNamespaceClient struct {
    21  	PersistEventhubsNamespaceError error
    22  	ResourceGroupError             error
    23  	AccessKeysError                error
    24  	AccessKeys                     *eventhub.AccessKeys
    25  	Tags                           azure.Tags
    26  	GetResourceGroupError          error
    27  	GetResourceGroupReturnValue    resources.Group
    28  	DeleteResourceGroupCalled      bool
    29  	DeleteResourceGroupError       error
    30  }
    31  
    32  func (nc *FakeNamespaceClient) ListResourceGroup(ctx context.Context, filter string, top *int32) (resources.GroupListResultPage, error) {
    33  	return resources.GroupListResultPage{}, nil
    34  }
    35  
    36  func (nc *FakeNamespaceClient) ListEHNamespaceByResourceGroup(ctx context.Context, resourceGroupName string) (eventhub.EHNamespaceListResultPage, error) {
    37  	return eventhub.EHNamespaceListResultPage{}, nil
    38  }
    39  
    40  func (nc *FakeNamespaceClient) GetEventhubAccessKeys(context.Context, string, string, string) (result eventhub.AccessKeys, err error) {
    41  	if nc.AccessKeys != nil {
    42  		return *nc.AccessKeys, nil
    43  	}
    44  	return eventhub.AccessKeys{
    45  		PrimaryConnectionString: ptr.String("Endpoint=sb://name/;"),
    46  	}, nc.AccessKeysError
    47  }
    48  
    49  func (nc *FakeNamespaceClient) CreateResourceGroup(ctx context.Context, config *azure.Config, name string, tags azure.Tags) (resources.Group, error) {
    50  	nc.Tags = tags
    51  	return resources.Group{
    52  		Name: ptr.String("my-resourcegroup"),
    53  	}, nc.ResourceGroupError
    54  }
    55  
    56  func (nc *FakeNamespaceClient) GetResourceGroup(context.Context, azure.Tags) (resources.Group, error) {
    57  	return nc.GetResourceGroupReturnValue, nc.GetResourceGroupError
    58  }
    59  
    60  func (nc *FakeNamespaceClient) CreateNamespace(ctx context.Context, azureCfg *azure.Config, groupName, namespace string, tags azure.Tags) (*eventhub.EHNamespace, error) {
    61  	nc.Tags = tags
    62  	return &eventhub.EHNamespace{
    63  		Name: ptr.String(namespace),
    64  	}, nc.PersistEventhubsNamespaceError
    65  }
    66  
    67  func (nc *FakeNamespaceClient) DeleteResourceGroup(context.Context, azure.Tags) (resources.GroupsDeleteFuture, error) {
    68  	nc.DeleteResourceGroupCalled = true
    69  	return resources.GroupsDeleteFuture{}, nc.DeleteResourceGroupError
    70  }
    71  
    72  func NewFakeNamespaceClientCreationError() azure.Interface {
    73  	return &FakeNamespaceClient{PersistEventhubsNamespaceError: fmt.Errorf("error while creating namespace")}
    74  }
    75  
    76  func NewFakeNamespaceClientListError() azure.Interface {
    77  	return &FakeNamespaceClient{AccessKeysError: fmt.Errorf("cannot list namespaces")}
    78  }
    79  
    80  func NewFakeNamespaceResourceGroupError() azure.Interface {
    81  	return &FakeNamespaceClient{ResourceGroupError: fmt.Errorf("cannot create resource group")}
    82  }
    83  
    84  func NewFakeNamespaceAccessKeysNil() azure.Interface {
    85  	return &FakeNamespaceClient{
    86  		// no error here
    87  		AccessKeysError: nil,
    88  		AccessKeys: &eventhub.AccessKeys{
    89  			// ups .. we got an AccessKey with nil connection string even though there was no error
    90  			PrimaryConnectionString: nil,
    91  		},
    92  	}
    93  }
    94  
    95  func NewFakeNamespaceClientHappyPath() *FakeNamespaceClient {
    96  	return &FakeNamespaceClient{}
    97  }
    98  
    99  func NewFakeNamespaceClientResourceGroupDoesNotExist() *FakeNamespaceClient {
   100  	return &FakeNamespaceClient{
   101  		GetResourceGroupError: azure.NewResourceGroupDoesNotExist("ups .. resource group does not exist"),
   102  	}
   103  }
   104  
   105  func NewFakeNamespaceClientResourceGroupConnectionError() *FakeNamespaceClient {
   106  	return &FakeNamespaceClient{
   107  		GetResourceGroupError: fmt.Errorf("ups .. can't connect to azure"),
   108  	}
   109  }
   110  
   111  func NewFakeNamespaceClientResourceGroupDeleteError() *FakeNamespaceClient {
   112  	return &FakeNamespaceClient{
   113  		DeleteResourceGroupError: fmt.Errorf("error while trying to delete resource group"),
   114  		GetResourceGroupReturnValue: resources.Group{
   115  			Response:   autorest.Response{},
   116  			Name:       ptr.String("fake-resource-group"),
   117  			Properties: &resources.GroupProperties{ProvisioningState: ptr.String(azure.FutureOperationSucceeded)},
   118  		},
   119  	}
   120  }
   121  
   122  func NewFakeNamespaceClientResourceGroupPropertiesError() *FakeNamespaceClient {
   123  	return &FakeNamespaceClient{
   124  		DeleteResourceGroupError: fmt.Errorf("error while trying to delete resource group"),
   125  	}
   126  }
   127  
   128  func NewFakeNamespaceClientResourceGroupInDeletionMode() *FakeNamespaceClient {
   129  	return &FakeNamespaceClient{
   130  		GetResourceGroupReturnValue: resources.Group{
   131  			Response:   autorest.Response{},
   132  			Name:       ptr.String("fake-resource-group"),
   133  			Properties: &resources.GroupProperties{ProvisioningState: ptr.String(azure.FutureOperationDeleting)},
   134  		},
   135  	}
   136  }
   137  
   138  func NewFakeNamespaceClientResourceGroupExists() *FakeNamespaceClient {
   139  	return &FakeNamespaceClient{
   140  		GetResourceGroupReturnValue: resources.Group{
   141  			Response:   autorest.Response{},
   142  			Name:       ptr.String("fake-resource-group"),
   143  			Properties: &resources.GroupProperties{ProvisioningState: ptr.String(azure.FutureOperationSucceeded)},
   144  		},
   145  	}
   146  }
   147  
   148  // ensure the fake Client is implementing the interface
   149  var _ azure.HyperscalerProvider = (*FakeHyperscalerProvider)(nil)
   150  
   151  type FakeHyperscalerProvider struct {
   152  	Client azure.Interface
   153  	Err    error
   154  }
   155  
   156  func (ac *FakeHyperscalerProvider) GetClient(config *azure.Config, logger logrus.FieldLogger) (azure.Interface, error) {
   157  	return ac.Client, ac.Err
   158  }
   159  
   160  func NewFakeHyperscalerProvider(client azure.Interface) azure.HyperscalerProvider {
   161  	return &FakeHyperscalerProvider{
   162  		Client: client,
   163  		Err:    nil,
   164  	}
   165  }
   166  
   167  func NewFakeHyperscalerProviderError() azure.HyperscalerProvider {
   168  	return &FakeHyperscalerProvider{
   169  		Client: nil,
   170  		Err:    fmt.Errorf("ups ... hyperscaler provider could not provide a hyperscaler Client"),
   171  	}
   172  }