module expression

import common

asset scripts:
    path: ../asset/run


test RangeExpressions:
    node n
    shell on n as git_init:
        git -c init.defaultBranch=master init -q
        git -c user.name=test -c user.email=test commit -q --allow-empty -m 'initial commit'
        cp "${scripts.path}/single.yaml" minici.yaml
        git add minici.yaml
        git -c user.name=test -c user.email=test commit -q -m 'minici.yaml'
        git rev-parse HEAD

        touch a
        git add a
        git -c user.name=test -c user.email=test commit -q -m a
        git rev-parse HEAD
        git rev-parse HEAD^{tree}

        touch b
        git add b
        git -c user.name=test -c user.email=test commit -q -m b
        git rev-parse HEAD
        git rev-parse HEAD^{tree}

        touch c
        git add c
        git -c user.name=test -c user.email=test commit -q -m c
        git rev-parse HEAD
        git rev-parse HEAD^{tree}

        touch d
        git add d
        git -c user.name=test -c user.email=test commit -q -m d
        git rev-parse HEAD
        git rev-parse HEAD^{tree}

        touch e
        git add e
        git -c user.name=test -c user.email=test commit -q -m e
        git rev-parse HEAD
        git rev-parse HEAD^{tree}

        git reset --hard HEAD~5
        git rev-parse HEAD

    expect /([0-9a-f]+)/ from git_init capture c_init
    expect /([0-9a-f]+)/ from git_init capture ca
    expect /([0-9a-f]+)/ from git_init capture ta
    expect /([0-9a-f]+)/ from git_init capture cb
    expect /([0-9a-f]+)/ from git_init capture tb
    expect /([0-9a-f]+)/ from git_init capture cc
    expect /([0-9a-f]+)/ from git_init capture tc
    expect /([0-9a-f]+)/ from git_init capture cd
    expect /([0-9a-f]+)/ from git_init capture td
    expect /([0-9a-f]+)/ from git_init capture ce
    expect /([0-9a-f]+)/ from git_init capture te
    expect /([0-9a-f]+)/ from git_init capture c_end

    guard (c_init == c_end)

    local:
        spawn on n as p args [ "run", "--rerun-all", "$ce:" ] killwith SIGINT
        expect from p:
            /job-enqueue $te:single/
            /job-start $te:single/
            /job-finish $te:single done/
        expect /(.*)/ from p capture finish
        guard (finish == "run-finish")

    local:
        spawn on n as p args [ "run", "--rerun-all", "$cb..$cd" ] killwith SIGINT
        expect from p:
            /job-enqueue $tc:single/
            /job-start $tc:single/
            /job-finish $tc:single done/
            /job-enqueue $td:single/
            /job-start $td:single/
            /job-finish $td:single done/
        expect /(.*)/ from p capture finish
        guard (finish == "run-finish")

    local:
        spawn on n as p args [ "run", "--rerun-all", "master..$cc" ] killwith SIGINT
        expect from p:
            /job-enqueue $ta:single/
            /job-start $ta:single/
            /job-finish $ta:single done/
            /job-enqueue $tb:single/
            /job-start $tb:single/
            /job-finish $tb:single done/
            /job-enqueue $tc:single/
            /job-start $tc:single/
            /job-finish $tc:single done/
        expect /(.*)/ from p capture finish
        guard (finish == "run-finish")

    local:
        local:
            shell on n:
                git reset --hard $ca

        spawn on n as p args [ "run", "--rerun-all", "watch(master)" ] killwith SIGINT
        expect from p:
            /job-enqueue $ta:single/
            /job-start $ta:single/
            /job-finish $ta:single done/

        local:
            shell on n:
                git reset --hard $cd

        expect from p:
            /job-enqueue (.*)/ capture td_single
        guard (td_single == "$td:single")
        expect from p:
            /job-start $td_single/
            /job-finish $td_single done/

        local:
            shell on n:
                git reset --hard $cb

        expect from p:
            /job-enqueue (.*)/ capture tb_single
        guard (tb_single == "$tb:single")
        expect from p:
            /job-start $tb_single/
            /job-finish $tb_single done/

    local:
        local:
            shell on n:
                git reset --hard $c_init

        spawn on n as p args [ "run", "--rerun-all", "master..watch(master)" ] killwith SIGINT
        expect from p /watch-branch-started master/

        shell on n:
            git reset --hard $cb
        expect from p:
            /job-enqueue $ta:single/
            /job-start $ta:single/
            /job-finish $ta:single done/
            /job-enqueue $tb:single/
            /job-start $tb:single/
            /job-finish $tb:single done/

        shell on n:
            git reset --hard $cd
        expect from p:
            /job-enqueue $tc:single/
            /job-start $tc:single/
            /job-finish $tc:single done/
            /job-enqueue $td:single/
            /job-start $td:single/
            /job-finish $td:single done/


test WatchTagList:
    node n
    shell on n as git_init:
        git -c init.defaultBranch=master init -q
        git -c user.name=test -c user.email=test commit -q --allow-empty -m 'initial commit'
        cp "${scripts.path}/single.yaml" minici.yaml
        git add minici.yaml
        git -c user.name=test -c user.email=test commit -q -m 'minici.yaml'
        git rev-parse HEAD

        touch a
        git add a
        git -c user.name=test -c user.email=test commit -q -m a
        git rev-parse HEAD
        git rev-parse HEAD^{tree}

        touch b
        git add b
        git -c user.name=test -c user.email=test commit -q -m b
        git rev-parse HEAD
        git rev-parse HEAD^{tree}

        touch c
        git add c
        git -c user.name=test -c user.email=test commit -q -m c
        git rev-parse HEAD
        git rev-parse HEAD^{tree}

        touch d
        git add d
        git -c user.name=test -c user.email=test commit -q -m d
        git rev-parse HEAD
        git rev-parse HEAD^{tree}

        touch e
        git add e
        git -c user.name=test -c user.email=test commit -q -m e
        git rev-parse HEAD
        git rev-parse HEAD^{tree}

        git reset --hard HEAD~5
        git rev-parse HEAD

    expect /([0-9a-f]+)/ from git_init capture c_init
    expect /([0-9a-f]+)/ from git_init capture ca
    expect /([0-9a-f]+)/ from git_init capture ta
    expect /([0-9a-f]+)/ from git_init capture cb
    expect /([0-9a-f]+)/ from git_init capture tb
    expect /([0-9a-f]+)/ from git_init capture cc
    expect /([0-9a-f]+)/ from git_init capture tc
    expect /([0-9a-f]+)/ from git_init capture cd
    expect /([0-9a-f]+)/ from git_init capture td
    expect /([0-9a-f]+)/ from git_init capture ce
    expect /([0-9a-f]+)/ from git_init capture te
    expect /([0-9a-f]+)/ from git_init capture c_end

    guard (c_init == c_end)

    shell on n:
        git -c user.name=test -c user.email=test tag -a -m . v1 $ca
        git -c user.name=test -c user.email=test tag -a -m . x1 $cb

    local:
        spawn on n as p args [ "run", "--rerun-all", "tags(v*)" ]
        expect from p:
            /job-enqueue $ta:single/
            /job-start $ta:single/
            /job-finish $ta:single done/
        expect /(.*)/ from p capture finish
        guard (finish == "run-finish")

    local:
        spawn on n as p args [ "run", "--rerun-all", "watch(tags(v*))" ] killwith SIGINT
        expect from p:
            /job-enqueue $ta:single/
            /job-start $ta:single/
            /job-finish $ta:single done/

        shell on n:
            git -c user.name=test -c user.email=test tag -a -m . v2 $cc

        expect from p:
            /job-enqueue $tc:single/
            /job-start $tc:single/
            /job-finish $tc:single done/

        shell on n:
            git -c user.name=test -c user.email=test tag -a -m . x2 $cd

        shell on n:
            git -c user.name=test -c user.email=test tag -a -m . v3 $ce

        local:
            expect from p /job-enqueue ([0-9a-f]+):single/ capture tid
            guard (tid == te)
        expect from p:
            /job-start $te:single/
            /job-finish $te:single done/