aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/test/aedifex/command/test.lux
blob: b63662bc000c349748e46b06e3a42cbc00aca17c (plain)
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
(.module:
  [lux #*
   ["_" test (#+ Test)]
   [abstract
    [monad (#+ do)]]
   [control
    ["." try]
    [concurrency
     ["." promise]]
    [parser
     ["." environment]]
    [security
     ["!" capability]]]
   [data
    ["." text ("#\." equivalence)]
    [collection
     ["." dictionary]]]
   [math
    ["." random]]
   [world
    ["." file]
    ["." shell]
    ["." program]]]
  ["." // #_
   ["@." version]
   ["@." build]
   ["$/#" // #_
    ["#." package]]]
  {#program
   ["." /
    ["/#" // #_
     ["#." build]
     ["/#" // #_
      ["#" profile (#+ Profile)]
      ["#." action]
      ["#." artifact
       ["#/." type]]
      ["#." dependency
       ["#/." resolution]]]]]})

(def: #export test
  Test
  (<| (_.covering /._)
      (do {! random.monad}
        [program (random.ascii/alpha 5)
         target (random.ascii/alpha 5)
         home (random.ascii/alpha 5)
         working-directory (random.ascii/alpha 5)
         #let [empty-profile (: Profile
                                (\ ///.monoid identity))
               with-target (: (-> Profile Profile)
                              (set@ #///.target (#.Some target)))
               with-program (: (-> Profile Profile)
                               (set@ #///.program (#.Some program)))
               
               profile (|> empty-profile
                           with-program
                           with-target)]
         resolution @build.resolution]
        ($_ _.and
            (let [fs (file.mock (\ file.default separator))
                  console (@version.echo "")]
              (wrap (do promise.monad
                      [verdict (do ///action.monad
                                 [_ (/.do! console (program.async (program.mock environment.empty home working-directory)) fs (@build.good-shell []) resolution profile)
                                  build-start (!.use (\ console read-line) [])
                                  build-end (!.use (\ console read-line) [])
                                  test-start (!.use (\ console read-line) [])
                                  test-end (!.use (\ console read-line) [])]
                                 (wrap (and (and (text\= //build.start build-start)
                                                 (text\= //build.success build-end))
                                            (and (text\= /.start test-start)
                                                 (text\= /.success test-end)))))]
                      (_.cover' [/.do!
                                 /.start /.success]
                                (try.default false verdict)))))
            (let [fs (file.mock (\ file.default separator))
                  console (@version.echo "")]
              (wrap (do promise.monad
                      [verdict (do ///action.monad
                                 [#let [bad-shell (shell.mock
                                                   (function (_ [actual-environment actual-working-directory actual-command actual-arguments])
                                                     (#try.Success
                                                      (: (shell.Simulation [])
                                                         (structure
                                                          (def: (on-read state)
                                                            (#try.Failure "on-read"))
                                                          (def: (on-error state)
                                                            (#try.Failure "on-error"))
                                                          (def: (on-write input state)
                                                            (#try.Failure "on-write"))
                                                          (def: (on-destroy state)
                                                            (#try.Failure "on-destroy"))
                                                          (def: (on-await state)
                                                            (#try.Success [state (if (text.ends-with? " build" actual-command)
                                                                                   shell.normal
                                                                                   shell.error)]))))))
                                                   [])]
                                  _ (/.do! console (program.async (program.mock environment.empty home working-directory)) fs bad-shell resolution profile)
                                  build-start (!.use (\ console read-line) [])
                                  build-end (!.use (\ console read-line) [])
                                  test-start (!.use (\ console read-line) [])
                                  test-end (!.use (\ console read-line) [])]
                                 (wrap (and (and (text\= //build.start build-start)
                                                 (text\= //build.success build-end))
                                            (and (text\= /.start test-start)
                                                 (text\= /.failure test-end)))))]
                      (_.cover' [/.failure]
                                (try.default false verdict)))))
            ))))