fake_server.go

Documentation: edge-infra.dev/pkg/edge/api/fake

     1  package fake
     2  
     3  import (
     4  	"encoding/json"
     5  	"io"
     6  	"net/http"
     7  	"net/http/httptest"
     8  	"strings"
     9  	"time"
    10  
    11  	"github.com/99designs/gqlgen/graphql"
    12  
    13  	"edge-infra.dev/pkg/edge/api/fake/mocks"
    14  	"edge-infra.dev/pkg/edge/api/graph/model"
    15  	"edge-infra.dev/pkg/edge/api/utils"
    16  )
    17  
    18  const (
    19  	TestNetworkServiceID = "test-networkservice-id-0"
    20  	TestServiceType      = "dns"
    21  	TestFamily           = "inet"
    22  	TestIP               = "1.1.1.1"
    23  	TestActivationCode   = "test-activationcode-0"
    24  )
    25  
    26  // APIRequestCallback can be used to customize the behaviour of the MockAPIServer
    27  // when a request is received. The body argument represents the incoming query
    28  // or mutation. A True ok return value indicates the function should process the
    29  // incoming request, while a False value indicates the MockAPIServer should use
    30  // another callback to process the request, either another callback supplied to
    31  // the GetMockAPIServer or the default MockAPIServer callback. If true, the
    32  // MockAPIServer returns a graphql bad response on a non-nil error, otherwise
    33  // returns data as an ok graphql response.
    34  type APIRequestsCallback func(body []byte) (data interface{}, ok bool, err error)
    35  
    36  func GetMockAPIServer(callbacks ...APIRequestsCallback) *httptest.Server {
    37  	server := utils.NewMockHTTPTestServer().AddAllowedContentType("application/json").DefaultNotFound()
    38  	server.Any("Mock API Requests", apiRequestsCallback(callbacks...), func(_ http.ResponseWriter, r *http.Request) bool {
    39  		return strings.HasPrefix(r.URL.String(), "/api/v2")
    40  	})
    41  	return server.Server
    42  }
    43  
    44  func apiRequestsCallback(callbacks ...APIRequestsCallback) func(w http.ResponseWriter, r *http.Request) { // nolint: gocyclo
    45  	return func(w http.ResponseWriter, r *http.Request) {
    46  		body, err := io.ReadAll(r.Body)
    47  		if err != nil {
    48  			utils.WriteBadResponse(w, nil)
    49  			return
    50  		}
    51  
    52  		for _, callback := range callbacks {
    53  			resp, matches, err := callback(body)
    54  			if !matches {
    55  				continue
    56  			}
    57  			if err != nil {
    58  				utils.WriteBadResponse(w, []byte(err.Error()))
    59  				return
    60  			}
    61  			data, err := wrapAsGraphqlResponse(resp)
    62  			if err != nil {
    63  				utils.WriteBadResponse(w, nil)
    64  				return
    65  			}
    66  			utils.WriteOkResponse(w, data)
    67  			return
    68  		}
    69  
    70  		switch {
    71  		case strings.Contains(string(body), "banners()"):
    72  			data, err := wrapAsGraphqlResponse(mocks.Banners())
    73  			if err != nil {
    74  				utils.WriteBadResponse(w, nil)
    75  				return
    76  			}
    77  			utils.WriteOkResponse(w, data)
    78  		case strings.Contains(string(body), "clusters(bannerEdgeId: $bannerEdgeId)"):
    79  			data, err := wrapAsGraphqlResponse(mocks.Clusters())
    80  			if err != nil {
    81  				utils.WriteBadResponse(w, nil)
    82  				return
    83  			}
    84  			utils.WriteOkResponse(w, data)
    85  		case strings.Contains(string(body), "updateClusterSecret(clusterEdgeId: $clusterEdgeId, secretType: $secretType, secretValue: $secretValue)"):
    86  			data, err := wrapAsGraphqlResponse(&UpdateClusterSecretResponse{Status: true})
    87  			if err != nil {
    88  				utils.WriteBadResponse(w, nil)
    89  				return
    90  			}
    91  			utils.WriteOkResponse(w, data)
    92  		case strings.Contains(string(body), "updateClusterNetworkServices(clusterEdgeId: $clusterEdgeId, networkServicesInfo: $networkServicesInfo)"):
    93  			data, err := wrapAsGraphqlResponse(&ModifyNetworkServiceResponse{
    94  				ClusterNetworkServices: []*model.ClusterNetworkServiceInfo{
    95  					{
    96  						NetworkServiceID: TestNetworkServiceID,
    97  						ServiceType:      TestServiceType,
    98  						IP:               TestIP,
    99  						Family:           TestFamily,
   100  					},
   101  				},
   102  			})
   103  			if err != nil {
   104  				utils.WriteBadResponse(w, nil)
   105  				return
   106  			}
   107  			utils.WriteOkResponse(w, data)
   108  		case strings.Contains(string(body), "createClusterNetworkServices(clusterEdgeId: $clusterEdgeId, networkServicesInfo: $networkServicesInfo)"):
   109  			data, err := wrapAsGraphqlResponse(&RegisterNetworkServiceResponse{
   110  				ClusterNetworkServices: []*model.ClusterNetworkServiceInfo{
   111  					{
   112  						NetworkServiceID: TestNetworkServiceID,
   113  						ServiceType:      TestServiceType,
   114  						IP:               TestIP,
   115  						Family:           TestFamily,
   116  					},
   117  				},
   118  			})
   119  			if err != nil {
   120  				utils.WriteBadResponse(w, nil)
   121  				return
   122  			}
   123  			utils.WriteOkResponse(w, data)
   124  		case strings.Contains(string(body), "deleteClusterNetworkService(clusterEdgeId: $clusterEdgeId, networkServiceId: $networkServiceId)"):
   125  			data, err := wrapAsGraphqlResponse(&DeleteNetworkServiceResponse{Status: true})
   126  			if err != nil {
   127  				utils.WriteBadResponse(w, nil)
   128  				return
   129  			}
   130  			utils.WriteOkResponse(w, data)
   131  		case strings.Contains(string(body), "terminals(clusterEdgeId: $clusterEdgeId)"):
   132  			data, err := wrapAsGraphqlResponse(&TerminalResponses{Terminals: []*model.Terminal{{
   133  				TerminalID:    "test-terminal-id-0",
   134  				ClusterEdgeID: "test-cluster-edge-id-0",
   135  				ClusterName:   "test-cluster-0",
   136  			}}})
   137  			if err != nil {
   138  				utils.WriteBadResponse(w, nil)
   139  				return
   140  			}
   141  			utils.WriteOkResponse(w, data)
   142  		case strings.Contains(string(body), "activationCode(terminalId: $terminalId)"):
   143  			data, err := wrapAsGraphqlResponse(&ActivationCodeResponses{ActivationCode: TestActivationCode})
   144  			if err != nil {
   145  				utils.WriteBadResponse(w, nil)
   146  				return
   147  			}
   148  			utils.WriteOkResponse(w, data)
   149  		case strings.Contains(string(body), "refreshActivationCode(terminalId: $terminalId)"):
   150  			data, err := wrapAsGraphqlResponse(&refreshActivationCodeResponse{ActivationCode: TestActivationCode})
   151  			if err != nil {
   152  				utils.WriteBadResponse(w, nil)
   153  				return
   154  			}
   155  			utils.WriteOkResponse(w, data)
   156  		case strings.Contains(string(body), "clusterSecret(clusterEdgeID: $clusterEdgeID, secretType: $secretType, version: $version)"):
   157  			data, err := wrapAsGraphqlResponse(&ViewClusterSecretResponse{ClusterSecret: "Pa55word"})
   158  			if err != nil {
   159  				utils.WriteBadResponse(w, nil)
   160  				return
   161  			}
   162  			utils.WriteOkResponse(w, data)
   163  		case strings.Contains(string(body), "clusterSecretLease(clusterEdgeID: $clusterEdgeID, secretType: $secretType){owner, expiresAt, secretTypes}"):
   164  			data, err := wrapAsGraphqlResponse(&ViewClusterSecretLeaseResponse{model.ClusterSecretLease{
   165  				Owner:       "testuser",
   166  				ExpiresAt:   time.Now().Local().Add(time.Hour * 48).Format(time.RFC3339),
   167  				SecretTypes: []string{"breakglass", "grub"},
   168  			}})
   169  			if err != nil {
   170  				utils.WriteBadResponse(w, nil)
   171  				return
   172  			}
   173  			utils.WriteOkResponse(w, data)
   174  		case strings.Contains(string(body), "revokeClusterSecretLease(clusterEdgeId: $clusterEdgeID, secretType: $secretType, username: $username)"):
   175  			data, err := wrapAsGraphqlResponse(&RevokeClusterSecretLeaseResponse{Status: true})
   176  			if err != nil {
   177  				utils.WriteBadResponse(w, nil)
   178  				return
   179  			}
   180  			utils.WriteOkResponse(w, data)
   181  		case strings.Contains(string(body), "releaseClusterSecretLease(clusterEdgeId: $clusterEdgeID, secretType: $secretType)"):
   182  			data, err := wrapAsGraphqlResponse(&ReleaseClusterSecretLeaseResponse{Status: true})
   183  			if err != nil {
   184  				utils.WriteBadResponse(w, nil)
   185  				return
   186  			}
   187  			utils.WriteOkResponse(w, data)
   188  		case strings.Contains(string(body), "updateBanner(bannerEdgeId: $bannerEdgeID, edgeSecurityCompliance: $securityCompliance){message, statusCode}"):
   189  			data, err := wrapAsGraphqlResponse(&UpdateBannerResponse{model.EdgeResponsePayload{
   190  				StatusCode: 200,
   191  				Message:    "Successfully updated test-banner-0",
   192  			}})
   193  			if err != nil {
   194  				utils.WriteBadResponse(w, nil)
   195  				return
   196  			}
   197  			utils.WriteOkResponse(w, data)
   198  		default:
   199  			return
   200  		}
   201  	}
   202  }
   203  
   204  func wrapAsGraphqlResponse(v interface{}) ([]byte, error) {
   205  	res, err := json.Marshal(v)
   206  	if err != nil {
   207  		return nil, err
   208  	}
   209  	resp := graphql.Response{Data: res}
   210  	return json.Marshal(resp)
   211  }
   212
View as plain text