daytonaio / daytona

Testing and Debugging

Daytona’s robust testing framework ensures stability and reliability. Here’s a breakdown of how testing and debugging is implemented:

  • Unit Testing: Unit tests are used to test individual components of the application in isolation. These tests are typically written using the testing package in Go and cover basic functionalities of each component.

    func (s *BuilderTestSuite) SetupTest() {
              s.buildResultStore = t_build.NewInMemoryBuildStore()
              s.mockGitService = mocks.NewMockGitService()
              factory := build.NewBuilderFactory(build.BuilderFactoryConfig{
                  BuilderConfig: build.BuilderConfig{
                      BuildResultStore: s.buildResultStore,
                  },
                  CreateGitService: func(projectDir string, w io.Writer) git.IGitService {
                      return s.mockGitService
                  },
              })
              s.mockGitService.On("CloneRepository", mock.Anything, mock.Anything).Return(nil)
              s.builder, _ = factory.Create(p, nil)
              err := s.buildResultStore.Save(&predefBuildResult)
              if err != nil {
                  panic(err)
              }
              expectedResults = append(expectedResults, &predefBuildResult)
          }
          
    func (s *BuilderTestSuite) TestSaveBuildResults() {
              expectedResults := append(expectedResults, &buildResult)
          
              require := s.Require()
          
              err := s.builder.SaveBuildResults(buildResult)
              require.NoError(err)
          
              savedResults, err := s.buildResultStore.List()
              require.NoError(err)
              require.ElementsMatch(expectedResults, savedResults)
          }

  • Integration Testing: Integration tests verify the interaction between different components of the application. These tests are typically written using the testing package in Go and often rely on mocking or stubbing dependencies.

    func TestWorkspaceService(t *testing.T) {
              workspaceStore := t_workspaces.NewInMemoryWorkspaceStore()
          
              containerRegistryService := mocks.NewMockContainerRegistryService()
          
              projectConfigService := mocks.NewMockProjectConfigService()
          
              targetStore := t_targets.NewInMemoryTargetStore()
              err := targetStore.Save(&target)
              require.Nil(t, err)
          
              apiKeyService := mocks.NewMockApiKeyService()
              gitProviderService := mocks.NewMockGitProviderService()
              provisioner := mocks.NewMockProvisioner()
          
              logsDir := t.TempDir()
          
              mockBuilderFactory := &mocks.MockBuilderFactory{}
          
              service := workspaces.NewWorkspaceService(workspaces.WorkspaceServiceConfig{
                  WorkspaceStore:           workspaceStore,
                  TargetStore:              targetStore,
                  ServerApiUrl:             serverApiUrl,
                  ServerUrl:                serverUrl,
                  ContainerRegistryService: containerRegistryService,
                  ProjectConfigService:     projectConfigService,
                  DefaultProjectImage:      defaultProjectImage,
                  DefaultProjectUser:       defaultProjectUser,
                  ApiKeyService:            apiKeyService,
                  Provisioner:              provisioner,
                  LoggerFactory:            logs.NewLoggerFactory(logsDir),
                  GitProviderService:       gitProviderService,
                  BuilderFactory:           mockBuilderFactory,
              })
          
              t.Run("CreateWorkspace", func(t *testing.T) {
                  var containerRegistry *containerregistry.ContainerRegistry
          
                  containerRegistryService.On("FindByImageName", defaultProjectImage).Return(containerRegistry, containerregistry.ErrContainerRegistryNotFound)
          
                  provisioner.On("CreateWorkspace", mock.Anything, &target).Return(nil)
                  provisioner.On("StartWorkspace", mock.Anything, &target).Return(nil)
          
                  apiKeyService.On("Generate", apikey.ApiKeyTypeWorkspace, createWorkspaceDto.Id).Return(createWorkspaceDto.Id, nil)
                  gitProviderService.On("GetLastCommitSha", createWorkspaceDto.Projects[0].Source.Repository).Return("123", nil)
          
                  baseApiUrl := "https://api.github.com"
                  gitProviderConfig := gitprovider.GitProviderConfig{
                      Id:         "github",
                      Username:   "test-username",
                      Token:      "test-token",
                      BaseApiUrl: &baseApiUrl,
                  }
          
                  for _, project := range createWorkspaceDto.Projects {
                      apiKeyService.On("Generate", apikey.ApiKeyTypeProject, fmt.Sprintf("%s/%s", createWorkspaceDto.Id, project.Name)).Return(project.Name, nil)
                  }
                  provisioner.On("CreateProject", mock.Anything, &target, containerRegistry, &gitProviderConfig).Return(nil)
                  provisioner.On("StartProject", mock.Anything, &target).Return(nil)
          
                  gitProviderService.On("GetConfigForUrl", "https://github.com/daytonaio/daytona").Return(&gitProviderConfig, nil)
          
                  workspace, err := service.CreateWorkspace(context.TODO(), createWorkspaceDto)
          
                  require.Nil(t, err)
                  require.NotNil(t, workspace)
          
                  workspaceEquals(t, createWorkspaceDto, workspace, defaultProjectImage)
              })
              // ... (rest of the tests)
          }

  • End-to-End Testing: End-to-end tests simulate real-world usage scenarios by testing the application from start to finish. These tests are typically written using the testing package in Go and may involve interacting with external services or databases.

    func TestAgent(t *testing.T) {
              buf := bytes.Buffer{}
              log.SetOutput(&buf)
          
              apiServer := mocks.NewMockRestServer(t, workspace1)
              defer apiServer.Close()
          
              mockConfig.Server.ApiUrl = apiServer.URL
          
              mockGitService := mock_git.NewMockGitService()
              mockGitService.On("RepositoryExists", project1).Return(true, nil)
              mockGitService.On("SetGitConfig", mock.Anything).Return(nil)
              mockGitService.On("GetGitStatus").Return(gitStatus1, nil)
          
              mockSshServer := mocks.NewMockSshServer()
              mockTailscaleServer := mocks.NewMockTailscaleServer()
          
              mockConfig.ProjectDir = t.TempDir()
          
              // Create a new Agent instance
              a := &agent.Agent{
                  Config:    mockConfig,
                  Git:       mockGitService,
                  Ssh:       mockSshServer,
                  Tailscale: mockTailscaleServer,
              }
          
              t.Run("Start agent", func(t *testing.T) {
                  err := a.Start()
          
                  require.Nil(t, err)
              })
          
              t.Cleanup(func() {
                  mockGitService.AssertExpectations(t)
                  mockSshServer.AssertExpectations(t)
                  mockTailscaleServer.AssertExpectations(t)
              })
          }

  • Mocking and Stubbing: Mocking and stubbing are used to isolate components of the application during testing. This allows developers to test specific functionality without relying on external services or databases. The testify/mock package is commonly used for mocking in Go.

    mockGitService.On("CloneRepository", mock.Anything, mock.Anything).Return(nil)
          
    provisioner.On("CreateWorkspace", mock.Anything, &target).Return(nil)

  • Logging: Daytona utilizes logging for debugging and monitoring purposes. The zerolog package is used for structured logging, which makes it easier to filter and analyze logs.

    func init() {
              logLevel := log.WarnLevel
          
              logLevelEnv, logLevelSet := os.LookupEnv("LOG_LEVEL")
          
              if logLevelSet {
                  var err error
                  logLevel, err = log.ParseLevel(logLevelEnv)
                  if err != nil {
                      logLevel = log.WarnLevel
                  }
              }
          
              log.SetLevel(logLevel)
          
              zerologLevel, err := zerolog.ParseLevel(logLevel.String())
              if err != nil {
                  zerologLevel = zerolog.ErrorLevel
              }
          
              zerolog.SetGlobalLevel(zerologLevel)
              zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
              zlog.Logger = zlog.Output(zerolog.ConsoleWriter{
                  Out:        &util.DebugLogWriter{},
                  TimeFormat: time.RFC3339,
              })
          
              golog.SetOutput(&util.DebugLogWriter{})
          }

  • Debugging Tools: Daytona supports several debugging tools, including:

    • Debuggers: Debuggers allow developers to step through code line-by-line, inspect variables, and set breakpoints.
    • Log Analyzers: Log analyzers help developers to filter, search, and analyze logs to identify issues.
    • Profilers: Profilers provide insights into the performance of the application and can help identify bottlenecks.

  • Development Environment: The .devcontainer.json file in the root of the project defines the development environment for the project. This file specifies the Docker image to use, the environment variables to set, and the commands to run after the container is created.

    {
            "name": "Daytona",
            "image": "ghcr.io/daytonaio/go-devcontainer:latest",
            "containerEnv": {
              "LOG_LEVEL": "debug",
              "DAYTONA_SERVER_MODE": "development",
              "CGO_ENABLED": "0",
              "DAYTONA_WS_ID": ""
            },
            "postCreateCommand": ".devcontainer/postcreate.sh",
            "remoteUser": "daytona"
          }

  • Testing with Docker: Daytona provides a comprehensive test suite that integrates with Docker. This ensures the application behaves as expected when run in a containerized environment.

    func TestAgentHostMode(t *testing.T) {
              mockGitService := mock_git.NewMockGitService()
              mockSshServer := mocks.NewMockSshServer()
              mockTailscaleServer := mocks.NewMockTailscaleServer()
          
              mockConfig := *mockConfig
              mockConfig.Mode = config.ModeHost
          
              // Create a new Agent instance
              a := &agent.Agent{
                  Config:    &mockConfig,
                  Git:       mockGitService,
                  Ssh:       mockSshServer,
                  Tailscale: mockTailscaleServer,
              }
          
              t.Run("Start agent in host mode", func(t *testing.T) {
                  mockConfig.Mode = config.ModeHost
                  err := a.Start()
          
                  require.Nil(t, err)
              })
          
              t.Cleanup(func() {
                  mockGitService.AssertExpectations(t)
                  mockSshServer.AssertExpectations(t)
                  mockTailscaleServer.AssertExpectations(t)
              })
          }

  • Error Handling and Recovery: Daytona implements robust error handling mechanisms to prevent unexpected failures. The application uses a combination of error handling techniques, including panic handling, error recovery, and logging. 

    if err != nil {
              panic(err)
          }

  • Security: Daytona incorporates security best practices throughout the codebase. This includes input validation, secure coding practices, and regular security audits.

    # SECURITY.md
          # Security Policy
          ## Reporting a Vulnerability
          To report a vulnerability, please contact us at

These methods collectively contribute to a comprehensive and effective approach to testing and debugging in Daytona.

Top-Level Directory Explanations

cmd/ - Contains command-line interface tools and scripts.

cmd/daytona/ - Subdirectory for Daytona-specific command-line tools.

cmd/daytona/config/ - Subdirectory for configuration files for Daytona command-line tools.

hack/ - Directory for Go development, including build scripts and dependencies.

internal/ - Private package directory for the project’s internal modules.

internal/constants/ - Subdirectory for project constants.

internal/testing/ - Subdirectory for testing-related modules.

internal/testing/agent/ - Subdirectory for testing agents.

internal/testing/docker/ - Subdirectory for Docker-related testing configurations.

internal/testing/git/ - Subdirectory for Git-related testing configurations.

internal/testing/logger/ - Subdirectory for logging configurations for tests.

internal/testing/provider/ - Subdirectory for testing providers.

internal/testing/server/ - Subdirectory for testing server configurations.

internal/util/ - Subdirectory for utility modules.

pkg/ - Go packages directory.

pkg/agent/ - Subdirectory for the project’s agent package.

pkg/api/ - Subdirectory for API-related packages.

pkg/api/controllers/ - Subdirectory for API controller handlers.

pkg/cmd/ - Subdirectory for command-line interface tools.

pkg/cmd/server/ - Subdirectory for server command-line tools.

pkg/cmd/telemetry/ - Subdirectory for telemetry command-line tools.

pkg/common/ - Subdirectory for common packages and utilities.

pkg/db/ - Subdirectory for database-related packages and scripts.

pkg/db/dto/ - Subdirectory for database data transfer objects.

pkg/docker/ - Subdirectory for Docker-related packages and scripts.

pkg/gitprovider/ - Subdirectory for Git provider package.

pkg/ide/ - Subdirectory for IDE-related packages and scripts.

pkg/server/ - Subdirectory for server-related packages and scripts.

pkg/server/apikeys/ - Subdirectory for API keys server-side.

pkg/server/profiledata/ - Subdirectory for profiledata server-side.

pkg/server/projectconfig/ - Subdirectory for project configuration server-side.

pkg/server/workspaces/ - Subdirectory for workspaces server-side.

pkg/telemetry/ - Subdirectory for telemetry-related packages and scripts.

pkg/views/ - Subdirectory for view templates.

Entrypoints and Where to Start

cmd/daytona/main.go - This is the main entrypoint of the Daytona application. The ‘main’ function initializes the application and starts the server. The ‘init’ function is used for initialization tasks such as setting up logging and loading configuration files.