tbdflow 0.27.0

A CLI to streamline your Git workflow for Trunk-Based Development.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

# ═══════════════════════════════════════════════════════════════════════════════
# tbdflow — Workflow Completion (merge & cleanup)
# ═══════════════════════════════════════════════════════════════════════════════
# User Story: As a developer, I want to merge my short-lived branch back to
# main with a single command so that integration is fast and friction-free.
# ═══════════════════════════════════════════════════════════════════════════════

feature "tbdflow Workflow Completion"

actors: Terminal

settings {
    timeout_seconds = 30
    stop_on_failure = true
    shell_path = "/bin/bash"
}

var REPO_DIR = "/tmp/tbdflow_complete_test"
var BARE_REPO = "/tmp/tbdflow_complete_bare.git"

# ═══════════════════════════════════════════════════════════════════════════════
# IMPLEMENTATION LAYER — Tasks hide the "how"
# ═══════════════════════════════════════════════════════════════════════════════

# --- Setup drivers ---

task init_repo(repo, bare) {
    Terminal run "rm -rf ${repo} ${bare} && mkdir -p ${repo}"
    Terminal run "git init --bare ${bare}"
    Terminal run "git -C ${repo} init && git -C ${repo} commit --allow-empty -m 'init'"
    Terminal run "git -C ${repo} remote add origin ${bare}"
    Terminal run "git -C ${repo} push -u origin main"
    Terminal set_cwd "${repo}"
}

task cleanup_repo(repo, bare) {
    Terminal run "rm -rf ${repo} ${bare}"
}

# --- Action drivers ---

task create_branch(type, name) {
    Terminal run "tbdflow branch -t ${type} -n ${name}"
}

task make_change(filename, content) {
    Terminal run "echo ${content} > ${filename}"
}

task commit(type, message) {
    Terminal run "tbdflow commit -t ${type} -m '${message}'"
}

task complete_branch(type, name) {
    Terminal run "tbdflow complete -t ${type} -n ${name}"
}

task sync() {
    Terminal run "tbdflow sync"
}

task check_status() {
    Terminal run "tbdflow status"
}

# --- Condition drivers ---

task verify_branch_merged_and_deleted() {
    Terminal last_command succeeded
    Terminal output_contains "merged into main"
    Terminal output_contains "deleted"
}

task verify_on_main_with_commit(expected_message) {
    Terminal last_command succeeded
    Terminal output_contains "${expected_message}"
    Terminal output_contains "On main branch"
}

task verify_working_tree_clean() {
    Terminal last_command succeeded
    Terminal output_contains "clean"
}

# ═══════════════════════════════════════════════════════════════════════════════
# BUSINESS SPECIFICATION LAYER — Scenarios describe the "what"
# ═══════════════════════════════════════════════════════════════════════════════

# AC1: `tbdflow complete` must merge the branch back to main.
# AC2: The feature branch must be deleted after merging.
# AC3: The commit history on main must contain the work from the branch.
# AC4: The working tree must be clean after completion.

scenario "Full branch lifecycle: create, commit, complete" {

    test Setup "Initialise test repository" {
        given:
            Test can_start
        when:
            init_repo("${REPO_DIR}", "${BARE_REPO}")
        then:
            Terminal last_command succeeded
    }

    test CreateBranch "Start a short-lived feature branch" {
        given:
            Test has_succeeded Setup
        when:
            create_branch("feat", "user-settings")
        then:
            Terminal last_command succeeded
            Terminal output_contains "feat/user-settings"
            Terminal output_not_contains "Error"
    }

    test CommitWork "Commit work on the branch" {
        given:
            Test has_succeeded CreateBranch
        when:
            make_change("settings.txt", "settings_page")
            commit("feat", "add user settings page")
        then:
            Terminal last_command succeeded
            Terminal output_not_contains "Error"
    }

    test CompleteWork "Merge the branch back to main" {
        given:
            Test has_succeeded CommitWork
        when:
            complete_branch("feat", "user-settings")
        then:
            verify_branch_merged_and_deleted()
    }

    test VerifyMergeOnMain "The commit exists on main after merge" {
        given:
            Test has_succeeded CompleteWork
        when:
            sync()
        then:
            verify_on_main_with_commit("add user settings page")
    }

    test WorkingTreeClean "Working directory is clean after complete" {
        given:
            Test has_succeeded VerifyMergeOnMain
        when:
            check_status()
        then:
            verify_working_tree_clean()
    }

    after {
        cleanup_repo("${REPO_DIR}", "${BARE_REPO}")
    }
}