208 lines
8.4 KiB
Go
208 lines
8.4 KiB
Go
//go:build integration_test
|
|
// +build integration_test
|
|
|
|
/*
|
|
Copyright 2021 The Dapr Authors
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package eventhubs
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/dapr/components-contrib/bindings"
|
|
"github.com/dapr/components-contrib/metadata"
|
|
"github.com/dapr/kit/logger"
|
|
)
|
|
|
|
const (
|
|
// Note: Reuse the environment variables names from the conformance tests where possible to support reuse of setup workflows
|
|
|
|
// iotHubConnectionStringEnvKey defines the key containing the integration test connection string
|
|
// For the default EventHub endpoint for an Azure IoT Hub, it will resemble:
|
|
// Endpoint=sb://<iotHubGeneratedNamespace>.servicebus.windows.net/;SharedAccessKeyName=service;SharedAccessKey=<key>;EntityPath=<iotHubGeneratedPath>
|
|
iotHubConnectionStringEnvKey = "AzureIotHubEventHubConnectionString"
|
|
iotHubConsumerGroupEnvKey = "AzureIotHubBindingsConsumerGroup"
|
|
iotHubNameEnvKey = "AzureIotHubName"
|
|
storageAccountNameEnvKey = "AzureBlobStorageAccount"
|
|
storageAccountKeyEnvKey = "AzureBlobStorageAccessKey"
|
|
azureCredentialsEnvKey = "AZURE_CREDENTIALS"
|
|
testStorageContainerName = "iothub-bindings-integration-test"
|
|
|
|
// use for AAD integration test
|
|
azureServicePrincipalClientIdEnvKey = "AzureCertificationServicePrincipalClientId"
|
|
azureServicePrincipalClientSecretEnvKey = "AzureCertificationServicePrincipalClientSecret"
|
|
azureTenantIdEnvKey = "AzureCertificationTenantId"
|
|
azureBlobStorageAccountEnvKey = "AzureBlobStorageAccount"
|
|
eventHubsBindingsContainerEnvKey = "AzureEventHubsBindingsContainer"
|
|
eventHubBindingsHubEnvKey = "AzureEventHubsBindingsHub"
|
|
eventHubBindingsNamespaceEnvKey = "AzureEventHubsBindingsNamespace"
|
|
eventHubsBindingsConsumerGroupEnvKey = "AzureEventHubsBindingsConsumerGroup"
|
|
)
|
|
|
|
func createIotHubBindingsMetadata() bindings.Metadata {
|
|
metadata := bindings.Metadata{
|
|
Base: metadata.Base{
|
|
Properties: map[string]string{
|
|
"connectionString": os.Getenv(iotHubConnectionStringEnvKey),
|
|
"consumerGroup": os.Getenv(iotHubConsumerGroupEnvKey),
|
|
"storageAccountName": os.Getenv(storageAccountNameEnvKey),
|
|
"storageAccountKey": os.Getenv(storageAccountKeyEnvKey),
|
|
"storageContainerName": testStorageContainerName,
|
|
},
|
|
},
|
|
}
|
|
|
|
return metadata
|
|
}
|
|
|
|
func createEventHubsBindingsAADMetadata() bindings.Metadata {
|
|
metadata := bindings.Metadata{
|
|
Base: metadata.Base{
|
|
Properties: map[string]string{
|
|
"consumerGroup": os.Getenv(eventHubsBindingsConsumerGroupEnvKey),
|
|
"storageAccountName": os.Getenv(azureBlobStorageAccountEnvKey),
|
|
"storageContainerName": os.Getenv(eventHubsBindingsContainerEnvKey),
|
|
"eventHub": os.Getenv(eventHubBindingsHubEnvKey),
|
|
"eventHubNamespace": os.Getenv(eventHubBindingsNamespaceEnvKey),
|
|
"azureTenantId": os.Getenv(azureTenantIdEnvKey),
|
|
"azureClientId": os.Getenv(azureServicePrincipalClientIdEnvKey),
|
|
"azureClientSecret": os.Getenv(azureServicePrincipalClientSecretEnvKey),
|
|
},
|
|
},
|
|
}
|
|
|
|
return metadata
|
|
}
|
|
|
|
func testEventHubsBindingsAADAuthentication(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
log := logger.NewLogger("bindings.azure.eventhubs.integration.test")
|
|
log.SetOutputLevel(logger.DebugLevel)
|
|
metadata := createEventHubsBindingsAADMetadata()
|
|
eventHubsBindings := NewAzureEventHubs(log)
|
|
|
|
err := eventHubsBindings.Init(context.Background(), metadata)
|
|
require.NoError(t, err)
|
|
|
|
req := &bindings.InvokeRequest{
|
|
Data: []byte("Integration test message"),
|
|
}
|
|
_, err = eventHubsBindings.Invoke(ctx, req)
|
|
require.NoError(t, err)
|
|
|
|
// Setup Read binding to capture readResponses in a closure so that test asserts can be
|
|
// performed on the main thread, including the case where the handler is never invoked.
|
|
var readResponses []bindings.ReadResponse
|
|
var handler bindings.Handler = func(_ context.Context, data *bindings.ReadResponse) ([]byte, error) {
|
|
readResponses = append(readResponses, *data)
|
|
return nil, nil
|
|
}
|
|
|
|
_, err = eventHubsBindings.Invoke(ctx, req)
|
|
require.NoError(t, err)
|
|
|
|
eventHubsBindings.Read(ctx, handler)
|
|
|
|
time.Sleep(1 * time.Second)
|
|
_, err = eventHubsBindings.Invoke(ctx, req)
|
|
require.NoError(t, err)
|
|
|
|
// Note: azure-event-hubs-go SDK defaultLeasePersistenceInterval is 5s
|
|
// Sleep long enough so that the azure event hubs SDK has time to persist updated checkpoints
|
|
// before the test process exits.
|
|
time.Sleep(10 * time.Second)
|
|
|
|
assert.Greater(t, len(readResponses), 0, "Failed to receive any EventHub events")
|
|
log.Infof("Received %d messages", len(readResponses))
|
|
for _, r := range readResponses {
|
|
log.Infof("Message metadata: %v", r.Metadata)
|
|
assert.Contains(t, string(r.Data), "Integration test message")
|
|
}
|
|
}
|
|
|
|
func testReadIotHubEvents(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
|
|
logger := logger.NewLogger("bindings.azure.eventhubs.integration.test")
|
|
eh := NewAzureEventHubs(logger)
|
|
err := eh.Init(context.Background(), createIotHubBindingsMetadata())
|
|
require.NoError(t, err)
|
|
|
|
// Invoke az CLI via bash script to send test IoT device events
|
|
// Requires the AZURE_CREDENTIALS environment variable to be already set (output of `az ad sp create-for-rbac`)
|
|
cmd := exec.Command("/bin/bash", "../../../tests/scripts/send-iot-device-events.sh")
|
|
cmd.Env = append(os.Environ(), fmt.Sprintf("IOT_HUB_NAME=%s", os.Getenv(iotHubNameEnvKey)))
|
|
out, err := cmd.CombinedOutput()
|
|
assert.NoError(t, err, "Error in send-iot-device-events.sh:\n%s", out)
|
|
|
|
// Setup Read binding to capture readResponses in a closure so that test asserts can be
|
|
// performed on the main thread, including the case where the handler is never invoked.
|
|
var readResponses []bindings.ReadResponse
|
|
handler := func(_ context.Context, data *bindings.ReadResponse) ([]byte, error) {
|
|
readResponses = append(readResponses, *data)
|
|
return nil, nil
|
|
}
|
|
|
|
eh.Read(ctx, handler)
|
|
|
|
// Note: azure-event-hubs-go SDK defaultLeasePersistenceInterval is 5s
|
|
// Sleep long enough so that the azure event hubs SDK has time to persist updated checkpoints
|
|
// before the test process exits.
|
|
time.Sleep(10 * time.Second)
|
|
|
|
assert.Greater(t, len(readResponses), 0, "Failed to receive any IotHub events")
|
|
logger.Infof("Received %d messages", len(readResponses))
|
|
for _, r := range readResponses {
|
|
logger.Infof("Message metadata: %v", r.Metadata)
|
|
assert.Contains(t, string(r.Data), "Integration test message")
|
|
|
|
// Verify expected IoT Hub device event metadata exists
|
|
// TODO: add device messages than can populate the sysPropPartitionKey and sysPropIotHubConnectionModuleID metadata
|
|
assert.Contains(t, r.Metadata, "x-opt-sequence-number", "IoT device event missing: x-opt-sequence-number")
|
|
assert.Contains(t, r.Metadata, "x-opt-enqueued-time", "IoT device event missing: x-opt-enqueued-time")
|
|
assert.Contains(t, r.Metadata, "x-opt-offset", "IoT device event missing: x-opt-offset")
|
|
assert.Contains(t, r.Metadata, "iothub-connection-device-id", "IoT device event missing: iothub-connection-device-id")
|
|
assert.Contains(t, r.Metadata, "iothub-connection-auth-generation-id", "IoT device event missing: iothub-connection-auth-generation-id")
|
|
assert.Contains(t, r.Metadata, "iothub-connection-auth-method", "IoT device event missing: iothub-connection-auth-method")
|
|
assert.Contains(t, r.Metadata, "iothub-enqueuedtime", "IoT device event missing: iothub-enqueuedtime")
|
|
assert.Contains(t, r.Metadata, "message-id", "IoT device event missing: message-id")
|
|
}
|
|
|
|
cancel()
|
|
if c, ok := eh.(io.Closer); ok {
|
|
c.Close()
|
|
}
|
|
}
|
|
|
|
func TestIntegrationCases(t *testing.T) {
|
|
connectionString := os.Getenv(iotHubConnectionStringEnvKey)
|
|
if connectionString != "" {
|
|
t.Run("Read IoT Hub events", testReadIotHubEvents)
|
|
}
|
|
serviceprincipal := os.Getenv(azureServicePrincipalClientIdEnvKey)
|
|
if serviceprincipal != "" {
|
|
t.Run("Event Hubs Binding AAD authentication", testEventHubsBindingsAADAuthentication)
|
|
}
|
|
}
|