+23 -58

spindle/engines/nixery/setup_steps.go

··· 2 2 3 3 import ( 4 4 "fmt" 5 5 - "path" 6 5 "strings" 7 6 8 7 "tangled.org/core/api/tangled" 9 9 - "tangled.org/core/workflow" 8 8 + "tangled.org/core/spindle/steps" 10 9 ) 11 10 12 11 func nixConfStep() Step { ··· 19 18 } 20 19 } 21 20 22 22 - // cloneOptsAsSteps processes clone options and adds corresponding steps 23 23 - // to the beginning of the workflow's step list if cloning is not skipped. 24 24 - // 25 25 - // the steps to do here are: 21 21 + // cloneStep uses the shared clone step builder to generate git clone commands. 22 22 + // The shared builder handles: 26 23 // - git init 27 24 // - git remote add origin <url> 28 25 // - git fetch --depth=<d> --recurse-submodules=<yes|no> <sha> 29 26 // - git checkout FETCH_HEAD 27 27 + // And supports all trigger types (push, PR, manual) and clone options. 30 28 func cloneStep(twf tangled.Pipeline_Workflow, tr tangled.Pipeline_TriggerMetadata, dev bool) Step { 31 31 - if twf.Clone.Skip { 32 32 - return Step{} 29 29 + // Use shared clone command builder 30 30 + cmds, err := steps.BuildCloneCommands(steps.CloneConfig{ 31 31 + Workflow: twf, 32 32 + TriggerMetadata: tr, 33 33 + DevMode: dev, 34 34 + WorkspaceDir: workspaceDir, 35 35 + }) 36 36 + if err != nil { 37 37 + // Return error step - this will cause the workflow to fail with a clear message 38 38 + return Step{ 39 39 + command: fmt.Sprintf("echo 'Failed to build clone commands: %s' && exit 1", err.Error()), 40 40 + name: "Clone repository into workspace (error)", 41 41 + } 33 42 } 34 43 35 35 - var commands []string 36 36 - 37 37 - // initialize git repo in workspace 38 38 - commands = append(commands, "git init") 39 39 - 40 40 - // add repo as git remote 41 41 - scheme := "https://" 42 42 - if dev { 43 43 - scheme = "http://" 44 44 - tr.Repo.Knot = strings.ReplaceAll(tr.Repo.Knot, "localhost", "host.docker.internal") 44 44 + // Check if cloning should be skipped 45 45 + if cmds.Skip { 46 46 + return Step{} 45 47 } 46 46 - url := scheme + path.Join(tr.Repo.Knot, tr.Repo.Did, tr.Repo.Repo) 47 47 - commands = append(commands, fmt.Sprintf("git remote add origin %s", url)) 48 48 49 49 - // run git fetch 50 50 - { 51 51 - var fetchArgs []string 52 52 - 53 53 - // default clone depth is 1 54 54 - depth := 1 55 55 - if twf.Clone.Depth > 1 { 56 56 - depth = int(twf.Clone.Depth) 57 57 - } 58 58 - fetchArgs = append(fetchArgs, fmt.Sprintf("--depth=%d", depth)) 59 59 - 60 60 - // optionally recurse submodules 61 61 - if twf.Clone.Submodules { 62 62 - fetchArgs = append(fetchArgs, "--recurse-submodules=yes") 63 63 - } 64 64 - 65 65 - // set remote to fetch from 66 66 - fetchArgs = append(fetchArgs, "origin") 67 67 - 68 68 - // set revision to checkout 69 69 - switch workflow.TriggerKind(tr.Kind) { 70 70 - case workflow.TriggerKindManual: 71 71 - // TODO: unimplemented 72 72 - case workflow.TriggerKindPush: 73 73 - fetchArgs = append(fetchArgs, tr.Push.NewSha) 74 74 - case workflow.TriggerKindPullRequest: 75 75 - fetchArgs = append(fetchArgs, tr.PullRequest.SourceSha) 76 76 - } 77 77 - 78 78 - commands = append(commands, fmt.Sprintf("git fetch %s", strings.Join(fetchArgs, " "))) 79 79 - } 80 80 - 81 81 - // run git checkout 82 82 - commands = append(commands, "git checkout FETCH_HEAD") 83 83 - 84 84 - cloneStep := Step{ 85 85 - command: strings.Join(commands, "\n"), 49 49 + // Nixery-specific: join commands with newlines for shell execution 50 50 + return Step{ 51 51 + command: strings.Join(cmds.All, "\n"), 86 52 name: "Clone repository into workspace", 87 53 } 88 88 - return cloneStep 89 54 } 90 55 91 56 // dependencyStep processes dependencies defined in the workflow.

+142

spindle/steps/clone.go

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

+421

spindle/steps/clone_test.go

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

+51

spindle/steps/types.go

··· 1 1 + package steps 2 2 + 3 3 + import "tangled.org/core/api/tangled" 4 4 + 5 5 + // CloneConfig contains all configuration needed to generate git clone commands 6 6 + type CloneConfig struct { 7 7 + // Workflow contains the pipeline workflow definition with clone options 8 8 + Workflow tangled.Pipeline_Workflow 9 9 + 10 10 + // TriggerMetadata contains information about what triggered the pipeline 11 11 + // (push event, PR, manual trigger, etc.) 12 12 + TriggerMetadata tangled.Pipeline_TriggerMetadata 13 13 + 14 14 + // DevMode enables development mode URL handling 15 15 + // (e.g., replacing localhost with host.docker.internal) 16 16 + DevMode bool 17 17 + 18 18 + // WorkspaceDir is the engine-specific path where the repository 19 19 + // should be cloned (e.g., "/tangled/workspace") 20 20 + WorkspaceDir string 21 21 + } 22 22 + 23 23 + // CloneCommands represents the git commands needed to clone a repository 24 24 + // Engines can execute these commands in their own way (shell script, 25 25 + // init container, Docker exec, etc.) 26 26 + type CloneCommands struct { 27 27 + // Init is the git init command 28 28 + Init string 29 29 + 30 30 + // Remote is the git remote add command 31 31 + Remote string 32 32 + 33 33 + // Fetch is the git fetch command with all options 34 34 + Fetch string 35 35 + 36 36 + // Checkout is the git checkout command 37 37 + Checkout string 38 38 + 39 39 + // All contains all commands in execution order 40 40 + All []string 41 41 + 42 42 + // RepoURL is the constructed repository URL 43 43 + RepoURL string 44 44 + 45 45 + // CommitSHA is the extracted commit SHA for this trigger 46 46 + CommitSHA string 47 47 + 48 48 + // Skip indicates whether cloning should be skipped entirely 49 49 + // (based on workflow.Clone.Skip flag) 50 50 + Skip bool 51 51 + }