examples_test.go

package getstream_test

import (
	"context"
	"testing"
	"time"

	"github.com/GetStream/getstream-go"
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

var (
	client *getstream.Client
	ctx    context.Context
)

func init() {
	ctx = context.Background()
}

func TestCreatingClient(t *testing.T) {
	apiKey := "key"
	apiSecret := "secret"
	client, err := getstream.NewClient(apiKey, apiSecret)
	require.NoError(t, err)
	require.NotNil(t, client)

	{
		// optionally you can create a new client with a different timeout
		client, err := getstream.NewClient(
			apiKey, apiSecret,
			getstream.WithTimeout(10_000*time.Millisecond),
		)
		require.NoError(t, err)
		require.NotNil(t, client)
	}
}

func TestCreateUserAndToken(t *testing.T) {
	client := initClient(t)

	// optional values are passed as pointers, you can use `getstream.PtrTo` to get pointers from literals of any type
	response, err := client.UpdateUsers(ctx, &getstream.UpdateUsersRequest{
		Users: map[string]getstream.UserRequest{
			"user-id": {
				ID:     "user-id",
				Name:   getstream.PtrTo("tommaso"),
				Role:   getstream.PtrTo("admin"),
				Custom: map[string]any{"country": "NL"},
			},
		},
	})
	require.NoError(t, err)
	require.NotNil(t, response)

	token, err := client.CreateToken("tommaso-id", getstream.WithExpiration(24*time.Hour))
	require.NoError(t, err)
	require.NotEmpty(t, token)
}

func TestCreateCall(t *testing.T) {
	client := initClient(t)

	call := client.Video().Call("livestream", uuid.NewString())

	members := []getstream.MemberRequest{
		{UserID: "john", Role: getstream.PtrTo("admin")},
		{UserID: "jack"},
	}

	callRequest := getstream.GetOrCreateCallRequest{
		Data: &getstream.CallRequest{
			CreatedByID: getstream.PtrTo("sacha"),
			Members:     members,
			Custom: map[string]any{
				"color": "blue",
			},
		},
	}

	response, err := call.GetOrCreate(ctx, &callRequest)
	require.NoError(t, err)
	require.NotEmpty(t, response)

	// pre-create the users
	{
		response, err := client.UpdateUsers(ctx, &getstream.UpdateUsersRequest{
			Users: map[string]getstream.UserRequest{
				"sara": {
					ID: "sara",
				},
				"emily": {
					ID: "emily",
				},
			},
		})
		require.NoError(t, err)
		require.NotNil(t, response)
	}

	// call members example:
	{
		// Call members need to be existing users (use `client.UpdateUsers` for that)
		// You can also update the role of existing members
		response, err := call.UpdateCallMembers(ctx, &getstream.UpdateCallMembersRequest{
			UpdateMembers: []getstream.MemberRequest{
				{UserID: "sara"},
				{UserID: "emily", Role: getstream.PtrTo("admin")},
			},
		})
		require.NoError(t, err)
		require.NotEmpty(t, response)
	}

	// call members remove example:
	{
		response, err := call.UpdateCallMembers(ctx, &getstream.UpdateCallMembersRequest{
			RemoveMembers: []string{
				"sara",
			},
		})
		require.NoError(t, err)
		require.NotEmpty(t, response)
	}

	// updating a call
	{
		// update some custom data for this call
		response, err := call.Update(ctx, &getstream.UpdateCallRequest{
			Custom: map[string]any{"color": "red"},
		})

		// update settings for this call
		response, err = call.Update(ctx, &getstream.UpdateCallRequest{
			SettingsOverride: &getstream.CallSettingsRequest{
				Screensharing: &getstream.ScreensharingSettingsRequest{
					Enabled:              getstream.PtrTo(true),
					AccessRequestEnabled: getstream.PtrTo(true),
				},
			},
		})

		require.NoError(t, err)
		require.NotEmpty(t, response)
		assert.Equal(t, map[string]any{"color": "red"}, response.Data.Call.Custom)
		assert.True(t, response.Data.Call.Settings.Screensharing.Enabled)
		assert.True(t, response.Data.Call.Settings.Screensharing.AccessRequestEnabled)
	}

	// go live endpoints
	{
		_, err = call.GoLive(ctx, &getstream.GoLiveRequest{})
		require.NoError(t, err)

		_, err = call.StopLive(ctx, &getstream.StopLiveRequest{})
		require.NoError(t, err)
	}

	// listing recordings and transcripts
	{
		_, err = call.ListTranscriptions(ctx, &getstream.ListTranscriptionsRequest{})
		require.NoError(t, err)

		_, err = call.ListRecordings(ctx, &getstream.ListRecordingsRequest{})
		require.NoError(t, err)
	}

	_, err = call.End(ctx, &getstream.EndCallRequest{})
	require.NoError(t, err)

	_, err = call.Delete(ctx, &getstream.DeleteCallRequest{})
	require.NoError(t, err)
}

func TestUsers(t *testing.T) {
	client := initClient(t)

	response, err := client.UpdateUsers(ctx, &getstream.UpdateUsersRequest{
		Users: map[string]getstream.UserRequest{
			"user_id": {
				ID:   "user_id",
				Role: getstream.PtrTo("admin"),
				Custom: map[string]interface{}{
					"color": "red",
				},
				Name:  getstream.PtrTo("This is a test user"),
				Image: getstream.PtrTo("link/to/profile/image"),
			},
		},
	})
	require.NoError(t, err)
	require.NotEmpty(t, response)

	{
		response, err := client.UpdateUsers(ctx, &getstream.UpdateUsersRequest{
			Users: map[string]getstream.UserRequest{
				"user_id": {
					ID:   "user_id",
					Role: getstream.PtrTo("user"),
					Custom: map[string]interface{}{
						"color": "blue",
					},
					Name:  getstream.PtrTo("This is a test user"),
					Image: getstream.PtrTo("link/to/profile/image"),
				},
			},
		})

		// or
		response, err = client.UpdateUsersPartial(ctx, &getstream.UpdateUsersPartialRequest{
			Users: []getstream.UpdateUserPartialRequest{
				{
					ID: "user_id",
					Set: map[string]interface{}{
						"new-field": "value",
					},
					Unset: []string{"name"},
				},
			},
		})

		require.NoError(t, err)
		require.NotEmpty(t, response)
		require.Empty(t, response.Data.Users["user_id"].Name)
		require.Equal(t, map[string]interface{}{
			"color":     "blue",
			"new-field": "value",
		}, response.Data.Users["user_id"].Custom)
	}

	aliceID := uuid.New().String()
	bobID := uuid.New().String()

	// pre-create the users
	{
		response, err := client.UpdateUsers(ctx, &getstream.UpdateUsersRequest{
			Users: map[string]getstream.UserRequest{
				aliceID: {
					ID: aliceID,
				},
				bobID: {
					ID: bobID,
				},
			},
		})
		require.NoError(t, err)
		require.NotNil(t, response)
	}

	{
		// deactivate one user
		response, err := client.DeactivateUser(ctx, aliceID, &getstream.DeactivateUserRequest{})
		require.NoError(t, err)
		require.NotEmpty(t, response)

		// reactivates the user
		_, err = client.ReactivateUser(ctx, aliceID, &getstream.ReactivateUserRequest{})
		require.NoError(t, err)

		// deactivates users in bulk, this is an async operation
		_, err = client.DeactivateUsers(ctx, &getstream.DeactivateUsersRequest{
			UserIds: []string{aliceID, bobID},
		})
		require.NoError(t, err)
	}

	// deleting users
	{
		t.Skip("this is just an example, don't run it")
		response, err := client.DeleteUsers(ctx, &getstream.DeleteUsersRequest{UserIds: []string{"<id>"}})

		// restore a soft-deleted user
		_, err = client.RestoreUsers(ctx, &getstream.RestoreUsersRequest{UserIds: []string{"<id>"}})

		require.NoError(t, err)
		require.NotEmpty(t, response)
	}
}

func TestCallToken(t *testing.T) {
	client := initClient(t)

	// the list of call IDs this token applies to
	tokenClaims := getstream.Claims{CallCIDs: []string{"default:call1", "livestream:call2"}}

	token, err := client.CreateToken("john",
		getstream.WithClaims(tokenClaims),
		getstream.WithExpiration(24*time.Hour),
	)
	require.NoError(t, err)
	require.NotEmpty(t, token)
}

func TestCreateChatChannelBasics(t *testing.T) {
	channel := initClient(t).Chat().Channel("messaging", uuid.NewString())

	response, err := channel.GetOrCreate(ctx, &getstream.GetOrCreateChannelRequest{
		Data: &getstream.ChannelInput{CreatedByID: getstream.PtrTo("john")},
	})
	require.NoError(t, err)
	assert.Equal(t, "messaging", response.Data.Channel.Type)
	assert.Equal(t, "john", response.Data.Channel.CreatedBy.ID)

	msgResponse, err := channel.SendMessage(ctx, &getstream.SendMessageRequest{
		Message: getstream.MessageRequest{
			Text:   getstream.PtrTo("hello"),
			UserID: getstream.PtrTo("john"),
		},
	})
	require.NoError(t, err)
	assert.Equal(t, "hello", msgResponse.Data.Message.Text)

	_, err = initClient(t).Chat().UpdateChannelType(ctx, "messaging", &getstream.UpdateChannelTypeRequest{
		Automod:          "disabled",
		AutomodBehavior:  "block",
		MaxMessageLength: 1000,
		CustomEvents:     getstream.PtrTo(true),
	})
	require.NoError(t, err)

	eventResponse, err := channel.SendEvent(ctx, &getstream.SendEventRequest{
		Event: getstream.EventRequest{
			Type:   "custom-event",
			UserID: getstream.PtrTo("john"),
		},
	})
	require.NoError(t, err)
	assert.Equal(t, "custom-event", eventResponse.Data.Event.Type)

	_, err = channel.MarkRead(ctx, &getstream.MarkReadRequest{
		UserID: getstream.PtrTo("john"),
	})
	require.NoError(t, err)

	deleteResponse, err := channel.Delete(ctx, &getstream.DeleteChannelRequest{})
	require.NoError(t, err)
	assert.NotNil(t, deleteResponse.Data.Channel.DeletedAt)
}

func TestCall_FrameRecording(t *testing.T) {
	t.Skip("this is just an example, don't run it")

	client := initClient(t)
	call := client.Video().Call("default", "call-id")

	_, err := call.GetOrCreate(ctx, &getstream.GetOrCreateCallRequest{
		Ring: getstream.PtrTo(true),
	})
	require.NoError(t, err)

	_, err = call.StartFrameRecording(ctx, &getstream.StartFrameRecordingRequest{})
	require.NoError(t, err)

	resp, err := call.GetOrCreate(ctx, &getstream.GetOrCreateCallRequest{})
	require.NoError(t, err)

	resp.Data.Call.Egress.FrameRecording.Status = "recording"

	_, err = call.StopFrameRecording(ctx, &getstream.StopFrameRecordingRequest{})
	require.NoError(t, err)
}

func TestCall_AutoFrameRecording(t *testing.T) {
	client := initClient(t)
	call_type_name := "default"

	// Automatically record calls
	resp, err := client.Video().UpdateCallType(ctx, call_type_name, &getstream.UpdateCallTypeRequest{
		Settings: &getstream.CallSettingsRequest{
			FrameRecording: &getstream.FrameRecordingSettingsRequest{
				Mode:                     "auto-on",
				CaptureIntervalInSeconds: 2,
			},
		},
	})
	require.NoError(t, err)
	assert.Equal(t, "auto-on", resp.Data.Settings.FrameRecording.Mode)
}