Your advanced code editor is loading.

Please wait a moment.

#editor-loading { display: none; }

package agent_test

import ( “bytes” “testing”

log "github.com/sirupsen/logrus" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require"

"github.com/daytonaio/daytona/internal/testing/agent/mocks" mock_git "github.com/daytonaio/daytona/internal/testing/git/mocks" "github.com/daytonaio/daytona/pkg/agent" "github.com/daytonaio/daytona/pkg/agent/config" "github.com/daytonaio/daytona/pkg/gitprovider" "github.com/daytonaio/daytona/pkg/workspace" "github.com/daytonaio/daytona/pkg/workspace/project"

)

var project1 = &project.Project{ Name: “test”, Repository: &gitprovider.GitRepository{ Id: “123”, Url: “https://github.com/daytonaio/daytona”, Name: “daytona”, }, WorkspaceId: “123”, Target: “local”, State: &project.ProjectState{ UpdatedAt: “123”, Uptime: 148, GitStatus: gitStatus1, }, }

var workspace1 = &workspace.Workspace{ Id: “123”, Name: “test”, Target: “local”, Projects: []*project.Project{ project1, }, }

var gitStatus1 = &project.GitStatus{ CurrentBranch: “main”, Files: []*project.FileStatus{{ Name: “File1”, Extra: “”, Staging: project.Modified, Worktree: project.Modified, }}, }

var mockConfig = &config.Config{ WorkspaceId: workspace1.Id, ProjectName: project1.Name, Server: config.DaytonaServerConfig{ ApiKey: “test-api-key”, }, Mode: config.ModeProject, }

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").Return(true, nil)
          mockGitService.On("SetGitConfig", mock.Anything, mock.Anything).Return(nil)
          mockGitService.On("GetGitStatus").Return(gitStatus1, nil)
          mockSshServer := mocks.NewMockSshServer()
          mockTailscaleServer := mocks.NewMockTailscaleServer()
          mockToolboxServer := mocks.NewMockToolboxServer()
          mockConfig.ProjectDir = t.TempDir()
          // Create a new Agent instance
          a := &agent.Agent{
          Config:    mockConfig,
          Git:       mockGitService,
          Ssh:       mockSshServer,
          Tailscale: mockTailscaleServer,
          Toolbox:   mockToolboxServer,
          }
          t.Run("Start agent", func(t *testing.T) {
          err := a.Start()
          require.Equal(t, err, mocks.SshServerStartError)
          })
          t.Cleanup(func() {
          mockGitService.AssertExpectations(t)
          mockSshServer.AssertExpectations(t)
          mockTailscaleServer.AssertExpectations(t)
          mockToolboxServer.AssertExpectations(t)
          })

}

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.Equal(t, err, mocks.SshServerStartError)
          })
          t.Cleanup(func() {
          mockGitService.AssertExpectations(t)
          mockSshServer.AssertExpectations(t)
          mockTailscaleServer.AssertExpectations(t)
          })

}

Explanation

The code is a test suite for the agent package of the daytona project, focusing on validating the Agent’s start function. The test suite sets up a mock environment, including a mock REST server for API calls, a mock Git service, and mock SSH and Tailscale servers.

Test Scenarios:

TestAgent: This test case starts the Agent with the ModeProject configuration, which means it should interact with a specific project within a workspace. It asserts that the Start function executes without errors, relying on the mock services for successful interactions.
TestAgentHostMode: This case tests the Start function with the ModeHost configuration, implying that the agent should operate on a broader level, likely targeting the entire workspace. Again, it asserts a successful execution without any errors.

Mock Objects:

mock_git.NewMockGitService(): A mocked GitService interface, simulating the interactions with the Git repository.
mocks.NewMockRestServer(t, workspace1): Creates a mock REST server with the provided workspace1 data, enabling testing of API calls.
mocks.NewMockSshServer(): A mocked SshServer interface, allowing testing of SSH functionalities.
mocks.NewMockTailscaleServer(): A mocked TailscaleServer interface, providing a way to test Tailscale interactions.

Key Highlights:

The tests focus on the Start function, validating that it operates correctly with different configurations.
Mock objects are used to simulate external systems, facilitating controlled testing without relying on real dependencies.
The require.Nil(t, err) assertion confirms that the Start function doesn’t return any errors.
Assertions are made on the mocked services to verify that they were called as expected during the tests.

Overall:

The test suite provides comprehensive validation of the Agent’s starting functionality with both project-level and host-level configurations. The use of mock objects ensures controlled and reliable testing, ensuring the Agent’s codebase remains robust.

Your advanced code editor is loading.

Please wait a moment.

Explanation

Graph

Symbols

We couldn't identify any entrypoints. If you believe this to be incorrect then please contact support.