github.com/dbernstein1/tyk@v2.9.0-beta9-dl-apic+incompatible/gateway/event_system_test.go (about)

     1  package gateway
     2  
     3  import (
     4  	"bytes"
     5  	"strings"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/sirupsen/logrus"
    10  
    11  	"github.com/TykTechnologies/tyk/apidef"
    12  	"github.com/TykTechnologies/tyk/config"
    13  )
    14  
    15  var (
    16  	handlerTypes = []apidef.TykEventHandlerName{
    17  		EH_LogHandler,
    18  		EH_WebHook,
    19  	}
    20  )
    21  
    22  func prepareSpecWithEvents(logger *logrus.Logger) (spec *APISpec) {
    23  	if logger == nil {
    24  		logger = log
    25  	}
    26  	def := &apidef.APIDefinition{
    27  		EventHandlers: apidef.EventHandlerMetaConfig{
    28  			Events: map[apidef.TykEvent][]apidef.EventHandlerTriggerConfig{
    29  				EventAuthFailure: {
    30  					{
    31  						Handler: EH_LogHandler,
    32  						HandlerMeta: map[string]interface{}{
    33  							"prefix": "testprefix",
    34  							"logger": logger,
    35  						},
    36  					},
    37  				},
    38  			},
    39  		},
    40  	}
    41  
    42  	spec = &APISpec{APIDefinition: def}
    43  	// From api_definition.go:
    44  	spec.EventPaths = make(map[apidef.TykEvent][]config.TykEventHandler)
    45  	for eventName, eventHandlerConfs := range def.EventHandlers.Events {
    46  		for _, handlerConf := range eventHandlerConfs {
    47  			eventHandlerInstance, err := EventHandlerByName(handlerConf, spec)
    48  
    49  			if err != nil {
    50  				log.Error("Failed to init event handler: ", err)
    51  			} else {
    52  				spec.EventPaths[eventName] = append(spec.EventPaths[eventName], eventHandlerInstance)
    53  			}
    54  
    55  		}
    56  	}
    57  
    58  	return spec
    59  }
    60  
    61  func prepareEventsConf() (conf *config.Config) {
    62  	return &config.Config{
    63  		EventHandlers: apidef.EventHandlerMetaConfig{
    64  			Events: map[apidef.TykEvent][]apidef.EventHandlerTriggerConfig{
    65  				EventQuotaExceeded: {
    66  					{
    67  						Handler: EH_LogHandler,
    68  						HandlerMeta: map[string]interface{}{
    69  							"prefix": "testprefix1",
    70  							"logger": log,
    71  						},
    72  					},
    73  				},
    74  				EventAuthFailure: {
    75  					{
    76  						Handler: EH_LogHandler,
    77  						HandlerMeta: map[string]interface{}{
    78  							"prefix": "testprefix2",
    79  							"logger": log,
    80  						},
    81  					},
    82  				},
    83  			},
    84  		},
    85  	}
    86  }
    87  
    88  func prepareEventHandlerConfig(handler apidef.TykEventHandlerName) (config apidef.EventHandlerTriggerConfig) {
    89  	config.Handler = handler
    90  	switch handler {
    91  	case EH_LogHandler:
    92  		config.HandlerMeta = map[string]interface{}{
    93  			"prefix": "testprefix",
    94  			"logger": log,
    95  		}
    96  	case EH_WebHook:
    97  		config.HandlerMeta = map[string]interface{}{}
    98  	}
    99  	return config
   100  }
   101  func TestEventHandlerByName(t *testing.T) {
   102  	spec := prepareSpecWithEvents(nil)
   103  	for _, handlerType := range handlerTypes {
   104  		handlerConfig := prepareEventHandlerConfig(handlerType)
   105  		_, err := EventHandlerByName(handlerConfig, spec)
   106  
   107  		// CP is disabled on standard builds:
   108  		if handlerType == EH_CoProcessHandler {
   109  			continue
   110  		}
   111  		if err != nil {
   112  			t.Fatalf("Couldn't get handler for %s\n", handlerType)
   113  		}
   114  	}
   115  }
   116  
   117  func TestLogMessageEventHandler(t *testing.T) {
   118  	buf := &bytes.Buffer{}
   119  	testLogger := logrus.New()
   120  	testLogger.Out = buf
   121  	spec := prepareSpecWithEvents(testLogger)
   122  	handler := spec.EventPaths[EventAuthFailure][0]
   123  	em := config.EventMessage{
   124  		Type: EventAuthFailure,
   125  		Meta: EventKeyFailureMeta{
   126  			EventMetaDefault: EventMetaDefault{Message: "Auth Failure"},
   127  			Path:             "/",
   128  			Origin:           "127.0.0.1",
   129  			Key:              "abc",
   130  		},
   131  		TimeStamp: time.Now().Local().String(),
   132  	}
   133  	lookup := "testprefix:AuthFailure"
   134  	handler.HandleEvent(em)
   135  	if !strings.Contains(buf.String(), lookup) {
   136  		t.Fatal("Couldn't find log message")
   137  	}
   138  }
   139  
   140  func TestInitGenericEventHandlers(t *testing.T) {
   141  	conf := prepareEventsConf()
   142  	initGenericEventHandlers(conf)
   143  	triggers := conf.GetEventTriggers()
   144  	if len(triggers) != 2 {
   145  		t.Fatal("EventTriggers length doesn't match")
   146  	}
   147  	for _, e := range []apidef.TykEvent{EventQuotaExceeded, EventAuthFailure} {
   148  		if triggers[e] == nil {
   149  			t.Fatalf("EventTriggers doesn't contain %s handlers", e)
   150  		}
   151  	}
   152  	for _, handlers := range triggers {
   153  		if len(handlers) != 1 {
   154  			t.Fatal("EventTriggers handlers length doesn't match")
   155  		}
   156  	}
   157  }
   158  
   159  func BenchmarkInitGenericEventHandlers(b *testing.B) {
   160  	b.ReportAllocs()
   161  
   162  	conf := prepareEventsConf()
   163  	for i := 0; i < b.N; i++ {
   164  		initGenericEventHandlers(conf)
   165  	}
   166  }