ldclient_test.go

package ldclient

import (
	"errors"
	"testing"
	"time"

	"github.com/launchdarkly/go-server-sdk/v7/internal/datastore"

	"github.com/launchdarkly/go-server-sdk/v7/internal/datakinds"
	"github.com/launchdarkly/go-server-sdk/v7/internal/sharedtest/mocks"

	"github.com/launchdarkly/go-sdk-common/v3/lduser"
	ldevents "github.com/launchdarkly/go-sdk-events/v3"
	"github.com/launchdarkly/go-server-sdk/v7/internal/sharedtest"
	"github.com/launchdarkly/go-server-sdk/v7/ldcomponents"
	"github.com/launchdarkly/go-server-sdk/v7/subsystems"
	"github.com/launchdarkly/go-server-sdk/v7/subsystems/ldstoretypes"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

const testSdkKey = "test-sdk-key"

func TestErrorFromComponentFactoryStopsClientCreation(t *testing.T) {
	fakeError := errors.New("sorry")

	doTest := func(name string, config Config, expectedError error) {
		t.Run(name, func(t *testing.T) {
			client, err := MakeCustomClient(testSdkKey, config, 0)
			assert.Nil(t, client)
			require.Error(t, err)
			assert.Equal(t, expectedError.Error(), err.Error())
		})
	}

	doTest("DataSource", Config{DataSource: mocks.ComponentConfigurerThatReturnsError[subsystems.DataSource]{Err: fakeError}}, fakeError)
	doTest("DataStore", Config{DataStore: mocks.ComponentConfigurerThatReturnsError[subsystems.DataStore]{Err: fakeError}}, fakeError)
	doTest("Events", Config{Events: mocks.ComponentConfigurerThatReturnsError[ldevents.EventProcessor]{Err: fakeError}}, fakeError)
	doTest("HTTP", Config{HTTP: ldcomponents.HTTPConfiguration().CACert([]byte{1})}, errors.New("invalid CA certificate data"))
}

func TestSecureModeHash(t *testing.T) {
	expected := "aa747c502a898200f9e4fa21bac68136f886a0e27aec70ba06daf2e2a5cb5597"
	key := "Message"
	config := Config{Offline: true}

	client, _ := MakeCustomClient("secret", config, 0*time.Second)

	hash := client.SecureModeHash(lduser.NewUser(key))

	assert.Equal(t, expected, hash)
}

func TestMakeCustomClientWithFailedInitialization(t *testing.T) {
	client, err := MakeCustomClient(testSdkKey, Config{
		Logging:    ldcomponents.Logging().Loggers(sharedtest.NewTestLoggers()),
		DataSource: mocks.DataSourceThatNeverInitializes(),
		Events:     ldcomponents.NoEvents(),
	}, time.Second)

	assert.NotNil(t, client)
	assert.Equal(t, err, ErrInitializationFailed)
}

// A populated persistent store is a data store, not a data source. It does not make client
// construction succeed when the data source never initializes. Evaluations still use its data.
func TestMakeCustomClientWithPopulatedPersistentStoreAndFailedDataSource(t *testing.T) {
	flag := alwaysTrueFlag
	persistentStore := mocks.NewMockPersistentDataStore()
	require.NoError(t, persistentStore.Init([]ldstoretypes.SerializedCollection{
		{
			Kind: datakinds.Features,
			Items: []ldstoretypes.KeyedSerializedItemDescriptor{
				{
					Key: flag.Key,
					Item: ldstoretypes.SerializedItemDescriptor{
						Version: flag.Version,
						SerializedItem: datakinds.Features.Serialize(
							ldstoretypes.ItemDescriptor{Version: flag.Version, Item: &flag}),
					},
				},
			},
		},
	}))

	client, err := MakeCustomClient(testSdkKey, Config{
		Logging:    ldcomponents.Logging().Loggers(sharedtest.NewTestLoggers()),
		DataSource: mocks.DataSourceThatNeverInitializes(),
		DataStore: ldcomponents.PersistentDataStore(
			mocks.SingleComponentConfigurer[subsystems.PersistentDataStore]{Instance: persistentStore},
		),
		Events: ldcomponents.NoEvents(),
	}, time.Second)

	require.NotNil(t, client)
	defer client.Close()
	assert.Equal(t, ErrInitializationFailed, err)

	value, _ := client.BoolVariation(flag.Key, testUser, false)
	assert.True(t, value)
}

func TestInvalidCharacterInSDKKey(t *testing.T) {
	badKey := "my-bad-key\n"

	_, err := MakeClient(badKey, time.Minute)
	assert.Error(t, err)
	assert.NotContains(t, err.Error(), "my-bad-key") // message shouldn't include the key value

	_, err = MakeCustomClient(badKey, Config{}, time.Minute)
	assert.Error(t, err)
	assert.NotContains(t, err.Error(), "my-bad-key")
}

func makeTestClient() *LDClient {
	return makeTestClientWithConfig(nil)
}

func makeTestClientWithConfig(modConfig func(*Config)) *LDClient {
	return makeTestClientWithConfigAndStore(modConfig, func(store subsystems.DataStore) {})
}

// makeTestClientWithConfigAndStore is a variant of makeTestClientWithConfig, which allows you to also pre-populate the
// client's in-memory data store with some test data. The second argument is a callback that provides you access to the
// store; then you can call Upsert/Init to inject data.
func makeTestClientWithConfigAndStore(modConfig func(*Config), populate func(store subsystems.DataStore)) *LDClient {
	config := Config{
		Offline:    false,
		DataStore:  populateStore(populate),
		DataSource: mocks.DataSourceThatIsAlwaysInitialized(),
		Events:     mocks.SingleComponentConfigurer[ldevents.EventProcessor]{Instance: &mocks.CapturingEventProcessor{}},
		Logging:    ldcomponents.Logging().Loggers(sharedtest.NewTestLoggers()),
	}
	if modConfig != nil {
		modConfig(&config)
	}
	client, _ := MakeCustomClient(testSdkKey, config, time.Duration(0))
	return client
}

// The populateStore type exist so that we can implement the ComponentConfigurer interface
// on it. When the SDK configures the data store, we can hook in additional logic to populate the store
// via the callback provided in makeTestClientWithConfigAndStore.
type populateStore func(store subsystems.DataStore)

func (populate populateStore) Build(context subsystems.ClientContext) (subsystems.DataStore, error) {
	inMemory := datastore.NewInMemoryDataStore(context.GetLogging().Loggers)
	populate(inMemory)
	return inMemory, nil
}