spindle: move the clone step out of nixery into a shared package for all spindle engines #827

ERROR

spindle/engines/nixery/setup_steps.go

Failed to calculate interdiff for this file.

REVERTED

spindle/workflow/clone.go

··· 1 1 - package workflow 2 2 - 3 3 - import ( 4 4 - "fmt" 5 5 - "strings" 6 6 - 7 7 - "tangled.org/core/api/tangled" 8 8 - "tangled.org/core/workflow" 9 9 - ) 10 10 - 11 11 - type CloneOptions struct { 12 12 - Workflow tangled.Pipeline_Workflow 13 13 - TriggerMetadata tangled.Pipeline_TriggerMetadata 14 14 - DevMode bool 15 15 - WorkspaceDir string 16 16 - } 17 17 - 18 18 - type CloneInfo struct { 19 19 - Commands []string 20 20 - RepoURL string 21 21 - CommitSHA string 22 22 - Skip bool 23 23 - } 24 24 - 25 25 - // GetCloneInfo generates git clone commands and metadata from pipeline trigger metadata 26 26 - func GetCloneInfo(opts CloneOptions) (*CloneInfo, error) { 27 27 - if opts.Workflow.Clone != nil && opts.Workflow.Clone.Skip { 28 28 - return &CloneInfo{Skip: true}, nil 29 29 - } 30 30 - 31 31 - commitSHA, err := extractCommitSHA(opts.TriggerMetadata) 32 32 - if err != nil { 33 33 - return nil, fmt.Errorf("failed to extract commit SHA: %w", err) 34 34 - } 35 35 - 36 36 - repoURL := buildRepoURL(opts.TriggerMetadata, opts.DevMode) 37 37 - 38 38 - workspaceDir := opts.WorkspaceDir 39 39 - if workspaceDir == "" { 40 40 - workspaceDir = "/tangled/workspace" 41 41 - } 42 42 - 43 43 - initCmd := fmt.Sprintf("git init %s", workspaceDir) 44 44 - remoteCmd := fmt.Sprintf("git remote add origin %s", repoURL) 45 45 - 46 46 - var cloneOpts tangled.Pipeline_CloneOpts 47 47 - if opts.Workflow.Clone != nil { 48 48 - cloneOpts = *opts.Workflow.Clone 49 49 - } 50 50 - fetchArgs := buildFetchArgs(cloneOpts, commitSHA) 51 51 - fetchCmd := fmt.Sprintf("git fetch %s", strings.Join(fetchArgs, " ")) 52 52 - 53 53 - checkoutCmd := "git checkout FETCH_HEAD" 54 54 - 55 55 - commands := []string{ 56 56 - initCmd, 57 57 - fmt.Sprintf("cd %s", workspaceDir), 58 58 - remoteCmd, 59 59 - fetchCmd, 60 60 - checkoutCmd, 61 61 - } 62 62 - 63 63 - return &CloneInfo{ 64 64 - Commands: commands, 65 65 - RepoURL: repoURL, 66 66 - CommitSHA: commitSHA, 67 67 - Skip: false, 68 68 - }, nil 69 69 - } 70 70 - 71 71 - // extractCommitSHA extracts the commit SHA from trigger metadata based on trigger type 72 72 - func extractCommitSHA(tr tangled.Pipeline_TriggerMetadata) (string, error) { 73 73 - switch workflow.TriggerKind(tr.Kind) { 74 74 - case workflow.TriggerKindPush: 75 75 - if tr.Push == nil { 76 76 - return "", fmt.Errorf("push trigger metadata is nil") 77 77 - } 78 78 - return tr.Push.NewSha, nil 79 79 - 80 80 - case workflow.TriggerKindPullRequest: 81 81 - if tr.PullRequest == nil { 82 82 - return "", fmt.Errorf("pull request trigger metadata is nil") 83 83 - } 84 84 - return tr.PullRequest.SourceSha, nil 85 85 - 86 86 - case workflow.TriggerKindManual: 87 87 - // Manual triggers don't have an explicit SHA in the metadata 88 88 - // For now, return empty string - could be enhanced to fetch from default branch 89 89 - // TODO: Implement manual trigger SHA resolution (fetch default branch HEAD) 90 90 - return "", nil 91 91 - 92 92 - default: 93 93 - return "", fmt.Errorf("unknown trigger kind: %s", tr.Kind) 94 94 - } 95 95 - } 96 96 - 97 97 - // buildRepoURL constructs the repository URL from trigger metadata 98 98 - func buildRepoURL(tr tangled.Pipeline_TriggerMetadata, devMode bool) string { 99 99 - if tr.Repo == nil { 100 100 - return "" 101 101 - } 102 102 - 103 103 - // Determine protocol 104 104 - scheme := "https://" 105 105 - if devMode { 106 106 - scheme = "http://" 107 107 - } 108 108 - 109 109 - // Get host from knot 110 110 - host := tr.Repo.Knot 111 111 - 112 112 - // In dev mode, replace localhost with host.docker.internal for Docker networking 113 113 - if devMode && strings.Contains(host, "localhost") { 114 114 - host = strings.ReplaceAll(host, "localhost", "host.docker.internal") 115 115 - } 116 116 - 117 117 - // Build URL: {scheme}{knot}/{did}/{repo} 118 118 - return fmt.Sprintf("%s%s/%s/%s", scheme, host, tr.Repo.Did, tr.Repo.Repo) 119 119 - } 120 120 - 121 121 - // buildFetchArgs constructs the arguments for git fetch based on clone options 122 122 - func buildFetchArgs(clone tangled.Pipeline_CloneOpts, sha string) []string { 123 123 - args := []string{} 124 124 - 125 125 - // Set fetch depth (default to 1 for shallow clone) 126 126 - depth := clone.Depth 127 127 - if depth == 0 { 128 128 - depth = 1 129 129 - } 130 130 - args = append(args, fmt.Sprintf("--depth=%d", depth)) 131 131 - 132 132 - // Add submodules if requested 133 133 - if clone.Submodules { 134 134 - args = append(args, "--recurse-submodules=yes") 135 135 - } 136 136 - 137 137 - // Add remote and SHA 138 138 - args = append(args, "origin") 139 139 - if sha != "" { 140 140 - args = append(args, sha) 141 141 - } 142 142 - 143 143 - return args 144 144 - }

REVERTED

spindle/workflow/clone_test.go

··· 1 1 - package workflow 2 2 - 3 3 - import ( 4 4 - "strings" 5 5 - "testing" 6 6 - 7 7 - "tangled.org/core/api/tangled" 8 8 - "tangled.org/core/workflow" 9 9 - ) 10 10 - 11 11 - func TestGetCloneInfo_PushTrigger(t *testing.T) { 12 12 - cfg := CloneOptions{ 13 13 - Workflow: tangled.Pipeline_Workflow{ 14 14 - Clone: &tangled.Pipeline_CloneOpts{ 15 15 - Depth: 1, 16 16 - Submodules: false, 17 17 - Skip: false, 18 18 - }, 19 19 - }, 20 20 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 21 21 - Kind: string(workflow.TriggerKindPush), 22 22 - Push: &tangled.Pipeline_PushTriggerData{ 23 23 - NewSha: "abc123", 24 24 - OldSha: "def456", 25 25 - Ref: "refs/heads/main", 26 26 - }, 27 27 - Repo: &tangled.Pipeline_TriggerRepo{ 28 28 - Knot: "example.com", 29 29 - Did: "did:plc:user123", 30 30 - Repo: "my-repo", 31 31 - }, 32 32 - }, 33 33 - DevMode: false, 34 34 - WorkspaceDir: "/tangled/workspace", 35 35 - } 36 36 - 37 37 - info, err := GetCloneInfo(cfg) 38 38 - if err != nil { 39 39 - t.Fatalf("GetCloneInfo failed: %v", err) 40 40 - } 41 41 - 42 42 - if info.Skip { 43 43 - t.Error("Expected Skip to be false") 44 44 - } 45 45 - 46 46 - if info.CommitSHA != "abc123" { 47 47 - t.Errorf("Expected CommitSHA 'abc123', got '%s'", info.CommitSHA) 48 48 - } 49 49 - 50 50 - expectedURL := "https://example.com/did:plc:user123/my-repo" 51 51 - if info.RepoURL != expectedURL { 52 52 - t.Errorf("Expected RepoURL '%s', got '%s'", expectedURL, info.RepoURL) 53 53 - } 54 54 - 55 55 - if len(info.Commands) != 5 { 56 56 - t.Errorf("Expected 5 commands, got %d", len(info.Commands)) 57 57 - } 58 58 - 59 59 - // Verify commands contain expected git operations 60 60 - allCmds := strings.Join(info.Commands, " ") 61 61 - if !strings.Contains(allCmds, "git init") { 62 62 - t.Error("Commands should contain 'git init'") 63 63 - } 64 64 - if !strings.Contains(allCmds, "git remote add origin") { 65 65 - t.Error("Commands should contain 'git remote add origin'") 66 66 - } 67 67 - if !strings.Contains(allCmds, "git fetch") { 68 68 - t.Error("Commands should contain 'git fetch'") 69 69 - } 70 70 - if !strings.Contains(allCmds, "abc123") { 71 71 - t.Error("Commands should contain commit SHA") 72 72 - } 73 73 - if !strings.Contains(allCmds, "git checkout FETCH_HEAD") { 74 74 - t.Error("Commands should contain 'git checkout FETCH_HEAD'") 75 75 - } 76 76 - } 77 77 - 78 78 - func TestGetCloneInfo_PullRequestTrigger(t *testing.T) { 79 79 - cfg := CloneOptions{ 80 80 - Workflow: tangled.Pipeline_Workflow{ 81 81 - Clone: &tangled.Pipeline_CloneOpts{ 82 82 - Depth: 1, 83 83 - Skip: false, 84 84 - }, 85 85 - }, 86 86 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 87 87 - Kind: string(workflow.TriggerKindPullRequest), 88 88 - PullRequest: &tangled.Pipeline_PullRequestTriggerData{ 89 89 - SourceSha: "pr-sha-789", 90 90 - SourceBranch: "feature-branch", 91 91 - TargetBranch: "main", 92 92 - Action: "opened", 93 93 - }, 94 94 - Repo: &tangled.Pipeline_TriggerRepo{ 95 95 - Knot: "example.com", 96 96 - Did: "did:plc:user123", 97 97 - Repo: "my-repo", 98 98 - }, 99 99 - }, 100 100 - DevMode: false, 101 101 - WorkspaceDir: "/tangled/workspace", 102 102 - } 103 103 - 104 104 - info, err := GetCloneInfo(cfg) 105 105 - if err != nil { 106 106 - t.Fatalf("GetCloneInfo failed: %v", err) 107 107 - } 108 108 - 109 109 - if info.CommitSHA != "pr-sha-789" { 110 110 - t.Errorf("Expected CommitSHA 'pr-sha-789', got '%s'", info.CommitSHA) 111 111 - } 112 112 - 113 113 - allCmds := strings.Join(info.Commands, " ") 114 114 - if !strings.Contains(allCmds, "pr-sha-789") { 115 115 - t.Error("Commands should contain PR commit SHA") 116 116 - } 117 117 - } 118 118 - 119 119 - func TestGetCloneInfo_ManualTrigger(t *testing.T) { 120 120 - cfg := CloneOptions{ 121 121 - Workflow: tangled.Pipeline_Workflow{ 122 122 - Clone: &tangled.Pipeline_CloneOpts{ 123 123 - Depth: 1, 124 124 - Skip: false, 125 125 - }, 126 126 - }, 127 127 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 128 128 - Kind: string(workflow.TriggerKindManual), 129 129 - Manual: &tangled.Pipeline_ManualTriggerData{ 130 130 - Inputs: nil, 131 131 - }, 132 132 - Repo: &tangled.Pipeline_TriggerRepo{ 133 133 - Knot: "example.com", 134 134 - Did: "did:plc:user123", 135 135 - Repo: "my-repo", 136 136 - }, 137 137 - }, 138 138 - DevMode: false, 139 139 - WorkspaceDir: "/tangled/workspace", 140 140 - } 141 141 - 142 142 - info, err := GetCloneInfo(cfg) 143 143 - if err != nil { 144 144 - t.Fatalf("GetCloneInfo failed: %v", err) 145 145 - } 146 146 - 147 147 - // Manual triggers don't have a SHA yet (TODO) 148 148 - if info.CommitSHA != "" { 149 149 - t.Errorf("Expected empty CommitSHA for manual trigger, got '%s'", info.CommitSHA) 150 150 - } 151 151 - } 152 152 - 153 153 - func TestGetCloneInfo_SkipFlag(t *testing.T) { 154 154 - cfg := CloneOptions{ 155 155 - Workflow: tangled.Pipeline_Workflow{ 156 156 - Clone: &tangled.Pipeline_CloneOpts{ 157 157 - Skip: true, 158 158 - }, 159 159 - }, 160 160 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 161 161 - Kind: string(workflow.TriggerKindPush), 162 162 - Push: &tangled.Pipeline_PushTriggerData{ 163 163 - NewSha: "abc123", 164 164 - }, 165 165 - Repo: &tangled.Pipeline_TriggerRepo{ 166 166 - Knot: "example.com", 167 167 - Did: "did:plc:user123", 168 168 - Repo: "my-repo", 169 169 - }, 170 170 - }, 171 171 - } 172 172 - 173 173 - info, err := GetCloneInfo(cfg) 174 174 - if err != nil { 175 175 - t.Fatalf("GetCloneInfo failed: %v", err) 176 176 - } 177 177 - 178 178 - if !info.Skip { 179 179 - t.Error("Expected Skip to be true") 180 180 - } 181 181 - 182 182 - if len(info.Commands) != 0 { 183 183 - t.Errorf("Expected no commands when Skip is true, got %d commands", len(info.Commands)) 184 184 - } 185 185 - } 186 186 - 187 187 - func TestGetCloneInfo_DevMode(t *testing.T) { 188 188 - cfg := CloneOptions{ 189 189 - Workflow: tangled.Pipeline_Workflow{ 190 190 - Clone: &tangled.Pipeline_CloneOpts{ 191 191 - Depth: 1, 192 192 - Skip: false, 193 193 - }, 194 194 - }, 195 195 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 196 196 - Kind: string(workflow.TriggerKindPush), 197 197 - Push: &tangled.Pipeline_PushTriggerData{ 198 198 - NewSha: "abc123", 199 199 - }, 200 200 - Repo: &tangled.Pipeline_TriggerRepo{ 201 201 - Knot: "localhost:3000", 202 202 - Did: "did:plc:user123", 203 203 - Repo: "my-repo", 204 204 - }, 205 205 - }, 206 206 - DevMode: true, 207 207 - WorkspaceDir: "/tangled/workspace", 208 208 - } 209 209 - 210 210 - info, err := GetCloneInfo(cfg) 211 211 - if err != nil { 212 212 - t.Fatalf("GetCloneInfo failed: %v", err) 213 213 - } 214 214 - 215 215 - // In dev mode, should use http:// and replace localhost with host.docker.internal 216 216 - expectedURL := "http://host.docker.internal:3000/did:plc:user123/my-repo" 217 217 - if info.RepoURL != expectedURL { 218 218 - t.Errorf("Expected dev mode URL '%s', got '%s'", expectedURL, info.RepoURL) 219 219 - } 220 220 - } 221 221 - 222 222 - func TestGetCloneInfo_DepthAndSubmodules(t *testing.T) { 223 223 - cfg := CloneOptions{ 224 224 - Workflow: tangled.Pipeline_Workflow{ 225 225 - Clone: &tangled.Pipeline_CloneOpts{ 226 226 - Depth: 10, 227 227 - Submodules: true, 228 228 - Skip: false, 229 229 - }, 230 230 - }, 231 231 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 232 232 - Kind: string(workflow.TriggerKindPush), 233 233 - Push: &tangled.Pipeline_PushTriggerData{ 234 234 - NewSha: "abc123", 235 235 - }, 236 236 - Repo: &tangled.Pipeline_TriggerRepo{ 237 237 - Knot: "example.com", 238 238 - Did: "did:plc:user123", 239 239 - Repo: "my-repo", 240 240 - }, 241 241 - }, 242 242 - DevMode: false, 243 243 - WorkspaceDir: "/tangled/workspace", 244 244 - } 245 245 - 246 246 - info, err := GetCloneInfo(cfg) 247 247 - if err != nil { 248 248 - t.Fatalf("GetCloneInfo failed: %v", err) 249 249 - } 250 250 - 251 251 - allCmds := strings.Join(info.Commands, " ") 252 252 - if !strings.Contains(allCmds, "--depth=10") { 253 253 - t.Error("Commands should contain '--depth=10'") 254 254 - } 255 255 - 256 256 - if !strings.Contains(allCmds, "--recurse-submodules=yes") { 257 257 - t.Error("Commands should contain '--recurse-submodules=yes'") 258 258 - } 259 259 - } 260 260 - 261 261 - func TestGetCloneInfo_DefaultDepth(t *testing.T) { 262 262 - cfg := CloneOptions{ 263 263 - Workflow: tangled.Pipeline_Workflow{ 264 264 - Clone: &tangled.Pipeline_CloneOpts{ 265 265 - Depth: 0, // Default should be 1 266 266 - Skip: false, 267 267 - }, 268 268 - }, 269 269 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 270 270 - Kind: string(workflow.TriggerKindPush), 271 271 - Push: &tangled.Pipeline_PushTriggerData{ 272 272 - NewSha: "abc123", 273 273 - }, 274 274 - Repo: &tangled.Pipeline_TriggerRepo{ 275 275 - Knot: "example.com", 276 276 - Did: "did:plc:user123", 277 277 - Repo: "my-repo", 278 278 - }, 279 279 - }, 280 280 - WorkspaceDir: "/tangled/workspace", 281 281 - } 282 282 - 283 283 - info, err := GetCloneInfo(cfg) 284 284 - if err != nil { 285 285 - t.Fatalf("GetCloneInfo failed: %v", err) 286 286 - } 287 287 - 288 288 - allCmds := strings.Join(info.Commands, " ") 289 289 - if !strings.Contains(allCmds, "--depth=1") { 290 290 - t.Error("Commands should default to '--depth=1'") 291 291 - } 292 292 - } 293 293 - 294 294 - func TestGetCloneInfo_NilPushData(t *testing.T) { 295 295 - cfg := CloneOptions{ 296 296 - Workflow: tangled.Pipeline_Workflow{ 297 297 - Clone: &tangled.Pipeline_CloneOpts{ 298 298 - Depth: 1, 299 299 - Skip: false, 300 300 - }, 301 301 - }, 302 302 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 303 303 - Kind: string(workflow.TriggerKindPush), 304 304 - Push: nil, // Nil push data should return error 305 305 - Repo: &tangled.Pipeline_TriggerRepo{ 306 306 - Knot: "example.com", 307 307 - Did: "did:plc:user123", 308 308 - Repo: "my-repo", 309 309 - }, 310 310 - }, 311 311 - WorkspaceDir: "/tangled/workspace", 312 312 - } 313 313 - 314 314 - _, err := GetCloneInfo(cfg) 315 315 - if err == nil { 316 316 - t.Error("Expected error when push data is nil") 317 317 - } 318 318 - 319 319 - if !strings.Contains(err.Error(), "push trigger metadata is nil") { 320 320 - t.Errorf("Expected error about nil push metadata, got: %v", err) 321 321 - } 322 322 - } 323 323 - 324 324 - func TestGetCloneInfo_NilPRData(t *testing.T) { 325 325 - cfg := CloneOptions{ 326 326 - Workflow: tangled.Pipeline_Workflow{ 327 327 - Clone: &tangled.Pipeline_CloneOpts{ 328 328 - Depth: 1, 329 329 - Skip: false, 330 330 - }, 331 331 - }, 332 332 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 333 333 - Kind: string(workflow.TriggerKindPullRequest), 334 334 - PullRequest: nil, // Nil PR data should return error 335 335 - Repo: &tangled.Pipeline_TriggerRepo{ 336 336 - Knot: "example.com", 337 337 - Did: "did:plc:user123", 338 338 - Repo: "my-repo", 339 339 - }, 340 340 - }, 341 341 - WorkspaceDir: "/tangled/workspace", 342 342 - } 343 343 - 344 344 - _, err := GetCloneInfo(cfg) 345 345 - if err == nil { 346 346 - t.Error("Expected error when pull request data is nil") 347 347 - } 348 348 - 349 349 - if !strings.Contains(err.Error(), "pull request trigger metadata is nil") { 350 350 - t.Errorf("Expected error about nil PR metadata, got: %v", err) 351 351 - } 352 352 - } 353 353 - 354 354 - func TestGetCloneInfo_CustomWorkspace(t *testing.T) { 355 355 - cfg := CloneOptions{ 356 356 - Workflow: tangled.Pipeline_Workflow{ 357 357 - Clone: &tangled.Pipeline_CloneOpts{ 358 358 - Depth: 1, 359 359 - Skip: false, 360 360 - }, 361 361 - }, 362 362 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 363 363 - Kind: string(workflow.TriggerKindPush), 364 364 - Push: &tangled.Pipeline_PushTriggerData{ 365 365 - NewSha: "abc123", 366 366 - }, 367 367 - Repo: &tangled.Pipeline_TriggerRepo{ 368 368 - Knot: "example.com", 369 369 - Did: "did:plc:user123", 370 370 - Repo: "my-repo", 371 371 - }, 372 372 - }, 373 373 - DevMode: false, 374 374 - WorkspaceDir: "/custom/path", 375 375 - } 376 376 - 377 377 - info, err := GetCloneInfo(cfg) 378 378 - if err != nil { 379 379 - t.Fatalf("GetCloneInfo failed: %v", err) 380 380 - } 381 381 - 382 382 - allCmds := strings.Join(info.Commands, " ") 383 383 - if !strings.Contains(allCmds, "/custom/path") { 384 384 - t.Error("Commands should use custom workspace directory") 385 385 - } 386 386 - } 387 387 - 388 388 - func TestGetCloneInfo_DefaultWorkspace(t *testing.T) { 389 389 - cfg := CloneOptions{ 390 390 - Workflow: tangled.Pipeline_Workflow{ 391 391 - Clone: &tangled.Pipeline_CloneOpts{ 392 392 - Depth: 1, 393 393 - Skip: false, 394 394 - }, 395 395 - }, 396 396 - TriggerMetadata: tangled.Pipeline_TriggerMetadata{ 397 397 - Kind: string(workflow.TriggerKindPush), 398 398 - Push: &tangled.Pipeline_PushTriggerData{ 399 399 - NewSha: "abc123", 400 400 - }, 401 401 - Repo: &tangled.Pipeline_TriggerRepo{ 402 402 - Knot: "example.com", 403 403 - Did: "did:plc:user123", 404 404 - Repo: "my-repo", 405 405 - }, 406 406 - }, 407 407 - DevMode: false, 408 408 - WorkspaceDir: "", // Empty should default to /tangled/workspace 409 409 - } 410 410 - 411 411 - info, err := GetCloneInfo(cfg) 412 412 - if err != nil { 413 413 - t.Fatalf("GetCloneInfo failed: %v", err) 414 414 - } 415 415 - 416 416 - allCmds := strings.Join(info.Commands, " ") 417 417 - if !strings.Contains(allCmds, "/tangled/workspace") { 418 418 - t.Error("Commands should default to /tangled/workspace") 419 419 - } 420 420 - }

NEW

appview/db/pipeline.go

··· 168 168 169 169 // this is a mega query, but the most useful one: 170 170 // get N pipelines, for each one get the latest status of its N workflows 171 171 - func GetPipelineStatuses(e Execer, limit int, filters ...filter) ([]models.Pipeline, error) { 171 171 + func GetPipelineStatuses(e Execer, filters ...filter) ([]models.Pipeline, error) { 172 172 var conditions []string 173 173 var args []any 174 174 for _, filter := range filters { ··· 205 205 join 206 206 triggers t ON p.trigger_id = t.id 207 207 %s 208 208 - order by p.created desc 209 209 - limit %d 210 210 - `, whereClause, limit) 208 208 + `, whereClause) 211 209 212 210 rows, err := e.Query(query, args...) 213 211 if err != nil {

NEW

appview/pages/templates/repo/compare/compare.html

··· 17 17 {{ end }} 18 18 19 19 {{ define "mainLayout" }} 20 20 - <div class="px-1 flex-grow col-span-full flex flex-col gap-4"> 20 20 + <div class="px-1 col-span-full flex flex-col gap-4"> 21 21 {{ block "contentLayout" . }} 22 22 {{ block "content" . }}{{ end }} 23 23 {{ end }}

NEW

appview/pages/templates/repo/settings/general.html

··· 58 58 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 59 59 </button> 60 60 </div> 61 61 - </fieldset> 61 61 + <fieldset> 62 62 </form> 63 63 {{ end }} 64 64

NEW

appview/pages/templates/user/fragments/editBio.html

··· 31 31 class="py-1 px-1 w-full" 32 32 name="pronouns" 33 33 placeholder="they/them" 34 34 + pattern="[a-zA-Z]{1,6}[\/\s\-][a-zA-Z]{1,6}" 34 35 value="{{ $pronouns }}" 35 36 > 36 37 </div>

NEW

appview/pipelines/pipelines.go

··· 82 82 83 83 ps, err := db.GetPipelineStatuses( 84 84 p.db, 85 85 - 30, 86 85 db.FilterEq("repo_owner", repoInfo.OwnerDid), 87 86 db.FilterEq("repo_name", repoInfo.Name), 88 87 db.FilterEq("knot", repoInfo.Knot), ··· 125 124 126 125 ps, err := db.GetPipelineStatuses( 127 126 p.db, 128 128 - 1, 129 127 db.FilterEq("repo_owner", repoInfo.OwnerDid), 130 128 db.FilterEq("repo_name", repoInfo.Name), 131 129 db.FilterEq("knot", repoInfo.Knot), ··· 195 193 196 194 ps, err := db.GetPipelineStatuses( 197 195 p.db, 198 198 - 1, 199 196 db.FilterEq("repo_owner", repoInfo.OwnerDid), 200 197 db.FilterEq("repo_name", repoInfo.Name), 201 198 db.FilterEq("knot", repoInfo.Knot),

NEW

appview/pulls/pulls.go

··· 178 178 179 179 ps, err := db.GetPipelineStatuses( 180 180 s.db, 181 181 - len(shas), 182 181 db.FilterEq("repo_owner", repoInfo.OwnerDid), 183 182 db.FilterEq("repo_name", repoInfo.Name), 184 183 db.FilterEq("knot", repoInfo.Knot), ··· 649 648 repoInfo := f.RepoInfo(user) 650 649 ps, err := db.GetPipelineStatuses( 651 650 s.db, 652 652 - len(shas), 653 651 db.FilterEq("repo_owner", repoInfo.OwnerDid), 654 652 db.FilterEq("repo_name", repoInfo.Name), 655 653 db.FilterEq("knot", repoInfo.Knot),

NEW

appview/repo/compare.go

··· 116 116 } 117 117 118 118 // if user is navigating to one of 119 119 - // /compare/{base}...{head} 120 119 // /compare/{base}/{head} 121 121 - var base, head string 122 122 - rest := chi.URLParam(r, "*") 123 123 - 124 124 - var parts []string 125 125 - if strings.Contains(rest, "...") { 126 126 - parts = strings.SplitN(rest, "...", 2) 127 127 - } else if strings.Contains(rest, "/") { 128 128 - parts = strings.SplitN(rest, "/", 2) 129 129 - } 130 130 - 131 131 - if len(parts) == 2 { 132 132 - base = parts[0] 133 133 - head = parts[1] 120 120 + // /compare/{base}...{head} 121 121 + base := chi.URLParam(r, "base") 122 122 + head := chi.URLParam(r, "head") 123 123 + if base == "" && head == "" { 124 124 + rest := chi.URLParam(r, "*") // master...feature/xyz 125 125 + parts := strings.SplitN(rest, "...", 2) 126 126 + if len(parts) == 2 { 127 127 + base = parts[0] 128 128 + head = parts[1] 129 129 + } 134 130 } 135 131 136 132 base, _ = url.PathUnescape(base)

NEW

appview/repo/repo_util.go

··· 1 1 package repo 2 2 3 3 import ( 4 4 + "crypto/rand" 5 5 + "math/big" 4 6 "slices" 5 7 "sort" 6 8 "strings" ··· 88 90 return 89 91 } 90 92 93 93 + func randomString(n int) string { 94 94 + const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" 95 95 + result := make([]byte, n) 96 96 + 97 97 + for i := 0; i < n; i++ { 98 98 + n, _ := rand.Int(rand.Reader, big.NewInt(int64(len(letters)))) 99 99 + result[i] = letters[n.Int64()] 100 100 + } 101 101 + 102 102 + return string(result) 103 103 + } 104 104 + 91 105 // grab pipelines from DB and munge that into a hashmap with commit sha as key 92 106 // 93 107 // golang is so blessed that it requires 35 lines of imperative code for this ··· 104 118 105 119 ps, err := db.GetPipelineStatuses( 106 120 d, 107 107 - len(shas), 108 121 db.FilterEq("repo_owner", repoInfo.OwnerDid), 109 122 db.FilterEq("repo_name", repoInfo.Name), 110 123 db.FilterEq("knot", repoInfo.Knot),

NEW

appview/repo/router.go

··· 61 61 // for example: 62 62 // /compare/master...some/feature 63 63 // /compare/master...example.com:another/feature <- this is a fork 64 64 + r.Get("/{base}/{head}", rp.Compare) 64 65 r.Get("/*", rp.Compare) 65 66 }) 66 67

NEW

nix/pkgs/knot-unwrapped.nix

··· 4 4 sqlite-lib, 5 5 src, 6 6 }: let 7 7 - version = "1.11.0-alpha"; 7 7 + version = "1.9.1-alpha"; 8 8 in 9 9 buildGoApplication { 10 10 pname = "knot";

NEW

spindle/engines/nixery/engine.go

··· 109 109 setup := &setupSteps{} 110 110 111 111 setup.addStep(nixConfStep()) 112 112 - setup.addStep(cloneStep(twf, *tpl.TriggerMetadata, e.cfg.Server.Dev)) 112 112 + setup.addStep(models.BuildCloneStep(twf, *tpl.TriggerMetadata, workspaceDir, e.cfg.Server.Dev)) 113 113 // this step could be empty 114 114 if s := dependencyStep(dwf.Dependencies); s != nil { 115 115 setup.addStep(*s)

NEW

spindle/models/clone.go

··· 1 1 + package models 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "strings" 6 6 + 7 7 + "tangled.org/core/api/tangled" 8 8 + "tangled.org/core/workflow" 9 9 + ) 10 10 + 11 11 + type CloneStep struct { 12 12 + name string 13 13 + kind StepKind 14 14 + commands []string 15 15 + } 16 16 + 17 17 + func (s CloneStep) Name() string { 18 18 + return s.name 19 19 + } 20 20 + 21 21 + func (s CloneStep) Commands() []string { 22 22 + return s.commands 23 23 + } 24 24 + 25 25 + func (s CloneStep) Command() string { 26 26 + return strings.Join(s.commands, "\n") 27 27 + } 28 28 + 29 29 + func (s CloneStep) Kind() StepKind { 30 30 + return s.kind 31 31 + } 32 32 + 33 33 + // BuildCloneStep generates git clone commands. 34 34 + // The shared builder handles: 35 35 + // - git init 36 36 + // - git remote add origin <url> 37 37 + // - git fetch --depth=<d> --recurse-submodules=<yes|no> <sha> 38 38 + // - git checkout FETCH_HEAD 39 39 + // And supports all trigger types (push, PR, manual) and clone options. 40 40 + func BuildCloneStep(twf tangled.Pipeline_Workflow, tr tangled.Pipeline_TriggerMetadata, workspaceDir string, dev bool) CloneStep { 41 41 + if twf.Clone != nil && twf.Clone.Skip { 42 42 + return CloneStep{} 43 43 + } 44 44 + 45 45 + commitSHA, err := extractCommitSHA(tr) 46 46 + if err != nil { 47 47 + return CloneStep{ 48 48 + kind: StepKindSystem, 49 49 + name: "Clone repository into workspace (error)", 50 50 + commands: []string{fmt.Sprintf("echo 'Failed to get clone info: %s' && exit 1", err.Error())}, 51 51 + } 52 52 + } 53 53 + 54 54 + repoURL := buildRepoURL(tr, dev) 55 55 + 56 56 + if workspaceDir == "" { 57 57 + workspaceDir = "/tangled/workspace" 58 58 + } 59 59 + 60 60 + initCmd := fmt.Sprintf("git init %s", workspaceDir) 61 61 + remoteCmd := fmt.Sprintf("git remote add origin %s", repoURL) 62 62 + 63 63 + var cloneOpts tangled.Pipeline_CloneOpts 64 64 + if twf.Clone != nil { 65 65 + cloneOpts = *twf.Clone 66 66 + } 67 67 + fetchArgs := buildFetchArgs(cloneOpts, commitSHA) 68 68 + fetchCmd := fmt.Sprintf("git fetch %s", strings.Join(fetchArgs, " ")) 69 69 + checkoutCmd := "git checkout FETCH_HEAD" 70 70 + 71 71 + return CloneStep{ 72 72 + kind: StepKindSystem, 73 73 + name: "Clone repository into workspace", 74 74 + commands: []string{ 75 75 + initCmd, 76 76 + fmt.Sprintf("cd %s", workspaceDir), 77 77 + remoteCmd, 78 78 + fetchCmd, 79 79 + checkoutCmd, 80 80 + }, 81 81 + } 82 82 + } 83 83 + 84 84 + // extractCommitSHA extracts the commit SHA from trigger metadata based on trigger type 85 85 + func extractCommitSHA(tr tangled.Pipeline_TriggerMetadata) (string, error) { 86 86 + switch workflow.TriggerKind(tr.Kind) { 87 87 + case workflow.TriggerKindPush: 88 88 + if tr.Push == nil { 89 89 + return "", fmt.Errorf("push trigger metadata is nil") 90 90 + } 91 91 + return tr.Push.NewSha, nil 92 92 + 93 93 + case workflow.TriggerKindPullRequest: 94 94 + if tr.PullRequest == nil { 95 95 + return "", fmt.Errorf("pull request trigger metadata is nil") 96 96 + } 97 97 + return tr.PullRequest.SourceSha, nil 98 98 + 99 99 + case workflow.TriggerKindManual: 100 100 + // Manual triggers don't have an explicit SHA in the metadata 101 101 + // For now, return empty string - could be enhanced to fetch from default branch 102 102 + // TODO: Implement manual trigger SHA resolution (fetch default branch HEAD) 103 103 + return "", nil 104 104 + 105 105 + default: 106 106 + return "", fmt.Errorf("unknown trigger kind: %s", tr.Kind) 107 107 + } 108 108 + } 109 109 + 110 110 + // buildRepoURL constructs the repository URL from trigger metadata 111 111 + func buildRepoURL(tr tangled.Pipeline_TriggerMetadata, devMode bool) string { 112 112 + if tr.Repo == nil { 113 113 + return "" 114 114 + } 115 115 + 116 116 + // Determine protocol 117 117 + scheme := "https://" 118 118 + if devMode { 119 119 + scheme = "http://" 120 120 + } 121 121 + 122 122 + // Get host from knot 123 123 + host := tr.Repo.Knot 124 124 + 125 125 + // In dev mode, replace localhost with host.docker.internal for Docker networking 126 126 + if devMode && strings.Contains(host, "localhost") { 127 127 + host = strings.ReplaceAll(host, "localhost", "host.docker.internal") 128 128 + } 129 129 + 130 130 + // Build URL: {scheme}{knot}/{did}/{repo} 131 131 + return fmt.Sprintf("%s%s/%s/%s", scheme, host, tr.Repo.Did, tr.Repo.Repo) 132 132 + } 133 133 + 134 134 + // buildFetchArgs constructs the arguments for git fetch based on clone options 135 135 + func buildFetchArgs(clone tangled.Pipeline_CloneOpts, sha string) []string { 136 136 + args := []string{} 137 137 + 138 138 + // Set fetch depth (default to 1 for shallow clone) 139 139 + depth := clone.Depth 140 140 + if depth == 0 { 141 141 + depth = 1 142 142 + } 143 143 + args = append(args, fmt.Sprintf("--depth=%d", depth)) 144 144 + 145 145 + // Add submodules if requested 146 146 + if clone.Submodules { 147 147 + args = append(args, "--recurse-submodules=yes") 148 148 + } 149 149 + 150 150 + // Add remote and SHA 151 151 + args = append(args, "origin") 152 152 + if sha != "" { 153 153 + args = append(args, sha) 154 154 + } 155 155 + 156 156 + return args 157 157 + }

NEW

spindle/models/clone_test.go

··· 1 1 + package models 2 2 + 3 3 + import ( 4 4 + "strings" 5 5 + "testing" 6 6 + 7 7 + "tangled.org/core/api/tangled" 8 8 + "tangled.org/core/workflow" 9 9 + ) 10 10 + 11 11 + func TestBuildCloneStep_PushTrigger(t *testing.T) { 12 12 + twf := tangled.Pipeline_Workflow{ 13 13 + Clone: &tangled.Pipeline_CloneOpts{ 14 14 + Depth: 1, 15 15 + Submodules: false, 16 16 + Skip: false, 17 17 + }, 18 18 + } 19 19 + tr := tangled.Pipeline_TriggerMetadata{ 20 20 + Kind: string(workflow.TriggerKindPush), 21 21 + Push: &tangled.Pipeline_PushTriggerData{ 22 22 + NewSha: "abc123", 23 23 + OldSha: "def456", 24 24 + Ref: "refs/heads/main", 25 25 + }, 26 26 + Repo: &tangled.Pipeline_TriggerRepo{ 27 27 + Knot: "example.com", 28 28 + Did: "did:plc:user123", 29 29 + Repo: "my-repo", 30 30 + }, 31 31 + } 32 32 + 33 33 + step := BuildCloneStep(twf, tr, "/tangled/workspace", false) 34 34 + 35 35 + if step.Kind() != StepKindSystem { 36 36 + t.Errorf("Expected StepKindSystem, got %v", step.Kind()) 37 37 + } 38 38 + 39 39 + if step.Name() != "Clone repository into workspace" { 40 40 + t.Errorf("Expected 'Clone repository into workspace', got '%s'", step.Name()) 41 41 + } 42 42 + 43 43 + commands := step.Commands() 44 44 + if len(commands) != 5 { 45 45 + t.Errorf("Expected 5 commands, got %d", len(commands)) 46 46 + } 47 47 + 48 48 + // Verify commands contain expected git operations 49 49 + allCmds := strings.Join(commands, " ") 50 50 + if !strings.Contains(allCmds, "git init") { 51 51 + t.Error("Commands should contain 'git init'") 52 52 + } 53 53 + if !strings.Contains(allCmds, "git remote add origin") { 54 54 + t.Error("Commands should contain 'git remote add origin'") 55 55 + } 56 56 + if !strings.Contains(allCmds, "git fetch") { 57 57 + t.Error("Commands should contain 'git fetch'") 58 58 + } 59 59 + if !strings.Contains(allCmds, "abc123") { 60 60 + t.Error("Commands should contain commit SHA") 61 61 + } 62 62 + if !strings.Contains(allCmds, "git checkout FETCH_HEAD") { 63 63 + t.Error("Commands should contain 'git checkout FETCH_HEAD'") 64 64 + } 65 65 + if !strings.Contains(allCmds, "https://example.com/did:plc:user123/my-repo") { 66 66 + t.Error("Commands should contain expected repo URL") 67 67 + } 68 68 + } 69 69 + 70 70 + func TestBuildCloneStep_PullRequestTrigger(t *testing.T) { 71 71 + twf := tangled.Pipeline_Workflow{ 72 72 + Clone: &tangled.Pipeline_CloneOpts{ 73 73 + Depth: 1, 74 74 + Skip: false, 75 75 + }, 76 76 + } 77 77 + tr := tangled.Pipeline_TriggerMetadata{ 78 78 + Kind: string(workflow.TriggerKindPullRequest), 79 79 + PullRequest: &tangled.Pipeline_PullRequestTriggerData{ 80 80 + SourceSha: "pr-sha-789", 81 81 + SourceBranch: "feature-branch", 82 82 + TargetBranch: "main", 83 83 + Action: "opened", 84 84 + }, 85 85 + Repo: &tangled.Pipeline_TriggerRepo{ 86 86 + Knot: "example.com", 87 87 + Did: "did:plc:user123", 88 88 + Repo: "my-repo", 89 89 + }, 90 90 + } 91 91 + 92 92 + step := BuildCloneStep(twf, tr, "/tangled/workspace", false) 93 93 + 94 94 + allCmds := strings.Join(step.Commands(), " ") 95 95 + if !strings.Contains(allCmds, "pr-sha-789") { 96 96 + t.Error("Commands should contain PR commit SHA") 97 97 + } 98 98 + } 99 99 + 100 100 + func TestBuildCloneStep_ManualTrigger(t *testing.T) { 101 101 + twf := tangled.Pipeline_Workflow{ 102 102 + Clone: &tangled.Pipeline_CloneOpts{ 103 103 + Depth: 1, 104 104 + Skip: false, 105 105 + }, 106 106 + } 107 107 + tr := tangled.Pipeline_TriggerMetadata{ 108 108 + Kind: string(workflow.TriggerKindManual), 109 109 + Manual: &tangled.Pipeline_ManualTriggerData{ 110 110 + Inputs: nil, 111 111 + }, 112 112 + Repo: &tangled.Pipeline_TriggerRepo{ 113 113 + Knot: "example.com", 114 114 + Did: "did:plc:user123", 115 115 + Repo: "my-repo", 116 116 + }, 117 117 + } 118 118 + 119 119 + step := BuildCloneStep(twf, tr, "/tangled/workspace", false) 120 120 + 121 121 + // Manual triggers don't have a SHA yet (TODO), so git fetch won't include a SHA 122 122 + allCmds := strings.Join(step.Commands(), " ") 123 123 + // Should still have basic git commands 124 124 + if !strings.Contains(allCmds, "git init") { 125 125 + t.Error("Commands should contain 'git init'") 126 126 + } 127 127 + if !strings.Contains(allCmds, "git fetch") { 128 128 + t.Error("Commands should contain 'git fetch'") 129 129 + } 130 130 + } 131 131 + 132 132 + func TestBuildCloneStep_SkipFlag(t *testing.T) { 133 133 + twf := tangled.Pipeline_Workflow{ 134 134 + Clone: &tangled.Pipeline_CloneOpts{ 135 135 + Skip: true, 136 136 + }, 137 137 + } 138 138 + tr := tangled.Pipeline_TriggerMetadata{ 139 139 + Kind: string(workflow.TriggerKindPush), 140 140 + Push: &tangled.Pipeline_PushTriggerData{ 141 141 + NewSha: "abc123", 142 142 + }, 143 143 + Repo: &tangled.Pipeline_TriggerRepo{ 144 144 + Knot: "example.com", 145 145 + Did: "did:plc:user123", 146 146 + Repo: "my-repo", 147 147 + }, 148 148 + } 149 149 + 150 150 + step := BuildCloneStep(twf, tr, "/tangled/workspace", false) 151 151 + 152 152 + // Empty step when skip is true 153 153 + if step.Name() != "" { 154 154 + t.Error("Expected empty step name when Skip is true") 155 155 + } 156 156 + if len(step.Commands()) != 0 { 157 157 + t.Errorf("Expected no commands when Skip is true, got %d commands", len(step.Commands())) 158 158 + } 159 159 + } 160 160 + 161 161 + func TestBuildCloneStep_DevMode(t *testing.T) { 162 162 + twf := tangled.Pipeline_Workflow{ 163 163 + Clone: &tangled.Pipeline_CloneOpts{ 164 164 + Depth: 1, 165 165 + Skip: false, 166 166 + }, 167 167 + } 168 168 + tr := tangled.Pipeline_TriggerMetadata{ 169 169 + Kind: string(workflow.TriggerKindPush), 170 170 + Push: &tangled.Pipeline_PushTriggerData{ 171 171 + NewSha: "abc123", 172 172 + }, 173 173 + Repo: &tangled.Pipeline_TriggerRepo{ 174 174 + Knot: "localhost:3000", 175 175 + Did: "did:plc:user123", 176 176 + Repo: "my-repo", 177 177 + }, 178 178 + } 179 179 + 180 180 + step := BuildCloneStep(twf, tr, "/tangled/workspace", true) 181 181 + 182 182 + // In dev mode, should use http:// and replace localhost with host.docker.internal 183 183 + allCmds := strings.Join(step.Commands(), " ") 184 184 + expectedURL := "http://host.docker.internal:3000/did:plc:user123/my-repo" 185 185 + if !strings.Contains(allCmds, expectedURL) { 186 186 + t.Errorf("Expected dev mode URL '%s' in commands", expectedURL) 187 187 + } 188 188 + } 189 189 + 190 190 + func TestBuildCloneStep_DepthAndSubmodules(t *testing.T) { 191 191 + twf := tangled.Pipeline_Workflow{ 192 192 + Clone: &tangled.Pipeline_CloneOpts{ 193 193 + Depth: 10, 194 194 + Submodules: true, 195 195 + Skip: false, 196 196 + }, 197 197 + } 198 198 + tr := tangled.Pipeline_TriggerMetadata{ 199 199 + Kind: string(workflow.TriggerKindPush), 200 200 + Push: &tangled.Pipeline_PushTriggerData{ 201 201 + NewSha: "abc123", 202 202 + }, 203 203 + Repo: &tangled.Pipeline_TriggerRepo{ 204 204 + Knot: "example.com", 205 205 + Did: "did:plc:user123", 206 206 + Repo: "my-repo", 207 207 + }, 208 208 + } 209 209 + 210 210 + step := BuildCloneStep(twf, tr, "/tangled/workspace", false) 211 211 + 212 212 + allCmds := strings.Join(step.Commands(), " ") 213 213 + if !strings.Contains(allCmds, "--depth=10") { 214 214 + t.Error("Commands should contain '--depth=10'") 215 215 + } 216 216 + 217 217 + if !strings.Contains(allCmds, "--recurse-submodules=yes") { 218 218 + t.Error("Commands should contain '--recurse-submodules=yes'") 219 219 + } 220 220 + } 221 221 + 222 222 + func TestBuildCloneStep_DefaultDepth(t *testing.T) { 223 223 + twf := tangled.Pipeline_Workflow{ 224 224 + Clone: &tangled.Pipeline_CloneOpts{ 225 225 + Depth: 0, // Default should be 1 226 226 + Skip: false, 227 227 + }, 228 228 + } 229 229 + tr := tangled.Pipeline_TriggerMetadata{ 230 230 + Kind: string(workflow.TriggerKindPush), 231 231 + Push: &tangled.Pipeline_PushTriggerData{ 232 232 + NewSha: "abc123", 233 233 + }, 234 234 + Repo: &tangled.Pipeline_TriggerRepo{ 235 235 + Knot: "example.com", 236 236 + Did: "did:plc:user123", 237 237 + Repo: "my-repo", 238 238 + }, 239 239 + } 240 240 + 241 241 + step := BuildCloneStep(twf, tr, "/tangled/workspace", false) 242 242 + 243 243 + allCmds := strings.Join(step.Commands(), " ") 244 244 + if !strings.Contains(allCmds, "--depth=1") { 245 245 + t.Error("Commands should default to '--depth=1'") 246 246 + } 247 247 + } 248 248 + 249 249 + func TestBuildCloneStep_NilPushData(t *testing.T) { 250 250 + twf := tangled.Pipeline_Workflow{ 251 251 + Clone: &tangled.Pipeline_CloneOpts{ 252 252 + Depth: 1, 253 253 + Skip: false, 254 254 + }, 255 255 + } 256 256 + tr := tangled.Pipeline_TriggerMetadata{ 257 257 + Kind: string(workflow.TriggerKindPush), 258 258 + Push: nil, // Nil push data should create error step 259 259 + Repo: &tangled.Pipeline_TriggerRepo{ 260 260 + Knot: "example.com", 261 261 + Did: "did:plc:user123", 262 262 + Repo: "my-repo", 263 263 + }, 264 264 + } 265 265 + 266 266 + step := BuildCloneStep(twf, tr, "/tangled/workspace", false) 267 267 + 268 268 + // Should return an error step 269 269 + if !strings.Contains(step.Name(), "error") { 270 270 + t.Error("Expected error in step name when push data is nil") 271 271 + } 272 272 + 273 273 + allCmds := strings.Join(step.Commands(), " ") 274 274 + if !strings.Contains(allCmds, "Failed to get clone info") { 275 275 + t.Error("Commands should contain error message") 276 276 + } 277 277 + if !strings.Contains(allCmds, "exit 1") { 278 278 + t.Error("Commands should exit with error") 279 279 + } 280 280 + } 281 281 + 282 282 + func TestBuildCloneStep_NilPRData(t *testing.T) { 283 283 + twf := tangled.Pipeline_Workflow{ 284 284 + Clone: &tangled.Pipeline_CloneOpts{ 285 285 + Depth: 1, 286 286 + Skip: false, 287 287 + }, 288 288 + } 289 289 + tr := tangled.Pipeline_TriggerMetadata{ 290 290 + Kind: string(workflow.TriggerKindPullRequest), 291 291 + PullRequest: nil, // Nil PR data should create error step 292 292 + Repo: &tangled.Pipeline_TriggerRepo{ 293 293 + Knot: "example.com", 294 294 + Did: "did:plc:user123", 295 295 + Repo: "my-repo", 296 296 + }, 297 297 + } 298 298 + 299 299 + step := BuildCloneStep(twf, tr, "/tangled/workspace", false) 300 300 + 301 301 + // Should return an error step 302 302 + if !strings.Contains(step.Name(), "error") { 303 303 + t.Error("Expected error in step name when pull request data is nil") 304 304 + } 305 305 + 306 306 + allCmds := strings.Join(step.Commands(), " ") 307 307 + if !strings.Contains(allCmds, "Failed to get clone info") { 308 308 + t.Error("Commands should contain error message") 309 309 + } 310 310 + } 311 311 + 312 312 + func TestBuildCloneStep_CustomWorkspace(t *testing.T) { 313 313 + twf := tangled.Pipeline_Workflow{ 314 314 + Clone: &tangled.Pipeline_CloneOpts{ 315 315 + Depth: 1, 316 316 + Skip: false, 317 317 + }, 318 318 + } 319 319 + tr := tangled.Pipeline_TriggerMetadata{ 320 320 + Kind: string(workflow.TriggerKindPush), 321 321 + Push: &tangled.Pipeline_PushTriggerData{ 322 322 + NewSha: "abc123", 323 323 + }, 324 324 + Repo: &tangled.Pipeline_TriggerRepo{ 325 325 + Knot: "example.com", 326 326 + Did: "did:plc:user123", 327 327 + Repo: "my-repo", 328 328 + }, 329 329 + } 330 330 + 331 331 + step := BuildCloneStep(twf, tr, "/custom/path", false) 332 332 + 333 333 + allCmds := strings.Join(step.Commands(), " ") 334 334 + if !strings.Contains(allCmds, "/custom/path") { 335 335 + t.Error("Commands should use custom workspace directory") 336 336 + } 337 337 + } 338 338 + 339 339 + func TestBuildCloneStep_DefaultWorkspace(t *testing.T) { 340 340 + twf := tangled.Pipeline_Workflow{ 341 341 + Clone: &tangled.Pipeline_CloneOpts{ 342 342 + Depth: 1, 343 343 + Skip: false, 344 344 + }, 345 345 + } 346 346 + tr := tangled.Pipeline_TriggerMetadata{ 347 347 + Kind: string(workflow.TriggerKindPush), 348 348 + Push: &tangled.Pipeline_PushTriggerData{ 349 349 + NewSha: "abc123", 350 350 + }, 351 351 + Repo: &tangled.Pipeline_TriggerRepo{ 352 352 + Knot: "example.com", 353 353 + Did: "did:plc:user123", 354 354 + Repo: "my-repo", 355 355 + }, 356 356 + } 357 357 + 358 358 + step := BuildCloneStep(twf, tr, "", false) // Empty should default to /tangled/workspace 359 359 + 360 360 + allCmds := strings.Join(step.Commands(), " ") 361 361 + if !strings.Contains(allCmds, "/tangled/workspace") { 362 362 + t.Error("Commands should default to /tangled/workspace") 363 363 + } 364 364 + }