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