nishikaze 0.1.0

Zephyr build system companion.
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

local t = require('spec.zync_test')
local Command = require('zync.api.commands.Command')
local parser_stub = require('spec.stubs.parser_stub')
local utils = require('zync.lib.utils')
local spy = require('luassert.spy')

local assert = t.assert

describe('Command class', function()
    local cmd_args

    before_each(function()
        -- common test fixtures for args
        cmd_args = {
            board = {
                flag = 'b',
                desc = 'App board',
                arg = 'board',
            },
            runner = {
                flag = 'r',
                desc = 'Board runner',
                arg = 'runner',
            },
            alt_runner = {
                flag = 'a',
                desc = 'Alternative runner',
                arg = 'alt_runner',
                skip_if = 'runner',
            },
            verbose = {
                flag = 'v',
                desc = 'Verbose output',
                -- no arg => option
            },
        }

        t.helpers.setup()
        parser_stub.load()
    end)

    after_each(function()
        parser_stub.revert()
        t.helpers.teardown()
    end)

    it('constructs a Command and wires parser + handler', function()
        local handler = spy.new(function(_) end)

        local cmd = Command:new(parser_stub, 'build', 'b', 'Build app', 'Build app using Ninja', handler)

        assert.is_table(cmd)
        assert.equals(Command, getmetatable(cmd))
        assert.equals(parser_stub, cmd.parser)
        assert.equals(handler, cmd.handler)

        -- argparse call chain: require_command(false):command(name):summary(summary):description(desc)
        assert.stub(parser_stub.require_command).was.called(1)
        assert.stub(parser_stub.require_command).was.called_with(parser_stub, false)

        assert.stub(parser_stub.command).was.called(1)
        assert.stub(parser_stub.command).was.called_with(parser_stub, 'build b')

        assert.stub(parser_stub.summary).was.called(1)
        assert.stub(parser_stub.summary).was.called_with(parser_stub, 'Build app')

        assert.stub(parser_stub.description).was.called(1)
        assert.stub(parser_stub.description).was.called_with(parser_stub, 'Build app using Ninja')
    end)

    it('does not set description when desc is nil/empty', function()
        local handler = spy.new(function(_) end)

        local cmd = Command:new(
            parser_stub,
            'config',
            'c', -- short
            'Configure app', -- summary
            nil, -- no desc
            handler
        )

        assert.is_table(cmd)
        assert.stub(parser_stub.description).was_not.called()
    end)

    it('args() stores args and registers options/flags with parser in sorted order', function()
        local handler = spy.new(function(_) end)
        local cmd = Command:new(parser_stub, 'build', 'b', 'Build app', 'Build app using Ninja', handler)

        cmd:args(cmd_args)

        -- verify args table stored
        assert.is_table(cmd.args)
        assert.is_true(t.helpers.table_contains(cmd.args, 'board'))
        assert.is_true(t.helpers.table_contains(cmd.args, 'runner'))
        assert.is_true(t.helpers.table_contains(cmd.args, 'alt_runner'))
        assert.is_true(t.helpers.table_contains(cmd.args, 'verbose'))

        -- verify sorted_args() ordering by arg name
        local sorted = cmd:sorted_args()
        local names = {}
        for i, sarg in ipairs(sorted) do
            names[i] = sarg.arg
        end

        -- alphabetical by key
        t.helpers.assert_tables_equal(names, { 'alt_runner', 'board', 'runner', 'verbose' })

        -- options: board, runner, alt_runner
        assert.stub(parser_stub.option).was.called(3)
        assert.stub(parser_stub.flag).was.called(1)

        -- create_arg() => "--<arg> -<flag>" for multi-char arg + single-char flag
        assert.stub(parser_stub.option).was.called_with(parser_stub, '--alt_runner -a', 'Alternative runner')
        assert.stub(parser_stub.option).was.called_with(parser_stub, '--board -b', 'App board')
        assert.stub(parser_stub.option).was.called_with(parser_stub, '--runner -r', 'Board runner')

        assert.stub(parser_stub.flag).was.called_with(parser_stub, '--verbose -v', 'Verbose output')

        -- every created option/flag should have args(1) called
        assert.stub(parser_stub.args).was.called(3)
        assert.stub(parser_stub.argname).was.called(3)
        assert.stub(parser_stub.convert).was.called(3)

        assert.stub(parser_stub.argname).was.called_with(parser_stub, '<alt_runner>')
        assert.stub(parser_stub.argname).was.called_with(parser_stub, '<board>')
        assert.stub(parser_stub.argname).was.called_with(parser_stub, '<runner>')
        assert.stub(parser_stub.convert).was.called_with(parser_stub, utils.tonumber_if_possible)
    end)

    it('parse() populates config from args and respects skip_if', function()
        local handler = spy.new(function(_) end)
        local cmd = Command:new(parser_stub, 'build', 'b', 'Build app', 'Build app using Ninja', handler)

        cmd:args(cmd_args)

        local cli_args = {
            board = 'nucleo_f767zi',
            runner = 'openocd',
            alt_runner = 'should_be_ignored',
            verbose = true,
        }

        local config = {}
        cmd:parse(cli_args, config)

        -- alt_runner skipped because skip_if = 'runner' and runner is present
        t.helpers.assert_tables_equal(config, {
            board = 'nucleo_f767zi',
            runner = 'openocd',
            verbose = true,
        })
    end)

    it('run() parses args and calls handler with config', function()
        local handler = spy.new(function(_) end)
        local cmd = Command:new(parser_stub, 'build', 'b', 'Build app', 'Build app using Ninja', handler)

        cmd:args(cmd_args)

        local cli_args = {
            board = 'nucleo_f767zi',
            runner = 'openocd',
        }

        local config = {}
        cmd:run(cli_args, config)

        -- handler was called exactly once with config
        assert.spy(handler).was.called(1)
        assert.spy(handler).was.called_with(config)

        t.helpers.assert_tables_equal(config, {
            board = 'nucleo_f767zi',
            runner = 'openocd',
        })
    end)
end)