github.com/Axway/agent-sdk@v1.1.101/pkg/transaction/eventgenerator_test.go (about)

     1  package transaction
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"net/http"
     7  	"net/http/httptest"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/Axway/agent-sdk/pkg/agent"
    12  	corecfg "github.com/Axway/agent-sdk/pkg/config"
    13  	"github.com/Axway/agent-sdk/pkg/traceability"
    14  	"github.com/Axway/agent-sdk/pkg/traceability/sampling"
    15  	"github.com/elastic/beats/v7/libbeat/common"
    16  	"github.com/stretchr/testify/assert"
    17  )
    18  
    19  type Config struct {
    20  	Central corecfg.CentralConfig `config:"central"`
    21  }
    22  
    23  func createMapperTestConfig(authURL, tenantID, apicDeployment, envName, envID string) *Config {
    24  	cfg := &Config{
    25  		Central: &corecfg.CentralConfiguration{
    26  			AgentType:                 corecfg.TraceabilityAgent,
    27  			URL:                       "https://xxx.axway.com",
    28  			PlatformURL:               "https://platform.xxx.com",
    29  			TenantID:                  tenantID,
    30  			APICDeployment:            apicDeployment,
    31  			Environment:               envName,
    32  			APIServerVersion:          "v1alpha1",
    33  			UsageReporting:            corecfg.NewUsageReporting("https://platform.xxx.com"),
    34  			MetricReporting:           corecfg.NewMetricReporting(),
    35  			ReportActivityFrequency:   2 * time.Minute,
    36  			APIValidationCronSchedule: "@daily",
    37  			ClientTimeout:             1 * time.Minute,
    38  			Auth: &corecfg.AuthConfiguration{
    39  				URL:        authURL,
    40  				ClientID:   "test",
    41  				Realm:      "Broker",
    42  				PrivateKey: "testdata/private_key.pem",
    43  				PublicKey:  "testdata/public_key",
    44  				Timeout:    10 * time.Second,
    45  			},
    46  		},
    47  	}
    48  	cfg.Central.SetEnvironmentID(envID)
    49  	return cfg
    50  }
    51  
    52  func createOfflineMapperTestConfig(envID string) *Config {
    53  	cfg := &Config{
    54  		Central: &corecfg.CentralConfiguration{
    55  			EnvironmentID: envID,
    56  			UsageReporting: &corecfg.UsageReportingConfiguration{
    57  				Offline: true,
    58  			},
    59  		},
    60  	}
    61  	cfg.Central.SetEnvironmentID(envID)
    62  	sampling.SetupSampling(sampling.DefaultConfig(), true)
    63  	return cfg
    64  }
    65  
    66  func TestCreateEventWithValidTokenRequest(t *testing.T) {
    67  	s := httptest.NewServer(http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
    68  		token := "{\"access_token\":\"somevalue\",\"expires_in\": 12235677}"
    69  		resp.Write([]byte(token))
    70  	}))
    71  	defer s.Close()
    72  
    73  	cfg := createMapperTestConfig(s.URL, "1111", "aaa", "env1", "1111")
    74  	// authCfg := cfg.Central.GetAuthConfig()
    75  	err := agent.Initialize(cfg.Central)
    76  	assert.Nil(t, err)
    77  
    78  	eventGenerator := NewEventGenerator()
    79  	dummyLogEvent := LogEvent{
    80  		TenantID:      cfg.Central.GetTenantID(),
    81  		Environment:   cfg.Central.GetAPICDeployment(),
    82  		EnvironmentID: cfg.Central.GetEnvironmentID(),
    83  	}
    84  	eventFields := make(common.MapStr)
    85  	eventFields["someKey.1"] = "someVal.1"
    86  	eventFields["someKey.2"] = "someVal.2"
    87  	eventFields["message"] = "existingMessage"
    88  
    89  	event, _ := eventGenerator.CreateEvent(dummyLogEvent, time.Now(), nil, eventFields, nil)
    90  	assert.NotNil(t, event)
    91  	// Validate that existing fields are added to generated event
    92  	assert.Equal(t, "someVal.1", event.Fields["someKey.1"])
    93  	assert.Equal(t, "someVal.2", event.Fields["someKey.2"])
    94  
    95  	msg := fmt.Sprintf("%v", event.Fields["message"])
    96  	fields := event.Fields["fields"].(map[string]string)
    97  	assert.NotNil(t, fields)
    98  	assert.NotNil(t, msg)
    99  	// Validate if message field from orgincal event fields is not included
   100  	assert.NotEqual(t, "existingMessage", event.Fields["message"])
   101  	var logEvent LogEvent
   102  	json.Unmarshal([]byte(msg), &logEvent)
   103  	assert.Equal(t, dummyLogEvent, logEvent)
   104  	assert.Equal(t, "somevalue", fields["token"])
   105  	assert.Equal(t, traceability.TransactionFlow, fields[traceability.FlowHeader])
   106  }
   107  
   108  func TestCreateEventWithInvalidTokenRequest(t *testing.T) {
   109  	s := httptest.NewServer(http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
   110  		resp.WriteHeader(http.StatusForbidden)
   111  	}))
   112  	defer s.Close()
   113  
   114  	cfg := createMapperTestConfig(s.URL, "1111", "aaa", "env1", "1111")
   115  	agent.Initialize(cfg.Central)
   116  	eventGenerator := NewEventGenerator()
   117  	dummyLogEvent := LogEvent{
   118  		TenantID:      cfg.Central.GetTenantID(),
   119  		Environment:   cfg.Central.GetAPICDeployment(),
   120  		EnvironmentID: cfg.Central.GetEnvironmentID(),
   121  	}
   122  
   123  	_, err := eventGenerator.CreateEvent(dummyLogEvent, time.Now(), nil, nil, nil)
   124  	assert.NotNil(t, err)
   125  	assert.Equal(t, "bad response from AxwayId: 403 Forbidden", err.Error())
   126  }
   127  
   128  func TestCreateEventsInOfflineMode(t *testing.T) {
   129  	s := httptest.NewServer(http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
   130  		resp.WriteHeader(http.StatusForbidden)
   131  	}))
   132  	defer s.Close()
   133  
   134  	cfg := createOfflineMapperTestConfig("1111")
   135  	agent.Initialize(cfg.Central)
   136  	eventGenerator := NewEventGenerator()
   137  	eventGenerator.SetUseTrafficForAggregation(false)
   138  	dummySummaryEvent := LogEvent{
   139  		EnvironmentID: cfg.Central.GetEnvironmentID(),
   140  	}
   141  
   142  	_, err := eventGenerator.CreateEvents(dummySummaryEvent, []LogEvent{}, time.Now(), nil, nil, nil)
   143  	assert.Nil(t, err)
   144  }