(.module:
  [lux #*
   ["_" test (#+ Test)]
   [abstract
    [monad (#+ do)]
    ["." predicate]]
   [control
    ["." try]
    [concurrency
     ["." promise]]
    [parser
     ["." environment]]]
   [data
    ["." text ("#\." equivalence)
     ["%" format (#+ format)]
     [encoding
      ["." utf8]]]
    [collection
     ["." dictionary]
     ["." set]]
    [format
     ["." xml]]]
   [math
    ["." random (#+ Random)]]
   [world
    ["." program]
    ["." file]]]
  ["." // #_
   ["@." version]
   ["$/#" // #_
    ["#." package]
    ["#." artifact]
    ["#." dependency #_
     ["#/." resolution]]]]
  {#program
   ["." /
    ["/#" // #_
     ["#." clean]
     ["/#" // #_
      ["#" profile]
      ["#." action]
      ["#." pom]
      ["#." package]
      ["#." artifact
       ["#/." type]]
      ["#." dependency
       ["#/." resolution]
       ["#/." deployment]
       ["#/." status]]
      ["#." repository
       ["#/." origin]
       ["#/." local]]]]]})

(def: #export test
  Test
  (<| (_.covering /._)
      (do random.monad
        [home (random.ascii/alpha 5)
         working_directory (random.ascii/alpha 5)

         dependee_artifact $///artifact.random
         depender_artifact (random.filter (predicate.complement
                                           (\ ///artifact.equivalence = dependee_artifact))
                                          $///artifact.random)

         [_ dependee_package] $///package.random
         [_ depender_package] $///package.random

         #let [dependee {#///dependency.artifact dependee_artifact
                         #///dependency.type ///artifact/type.lux_library}
               depender {#///dependency.artifact depender_artifact
                         #///dependency.type ///artifact/type.lux_library}

               dependee_pom (|> (\ ///.monoid identity)
                                (set@ #///.identity (#.Some dependee_artifact))
                                ///pom.write
                                try.assume)
               depender_pom (|> (\ ///.monoid identity)
                                (set@ #///.identity (#.Some depender_artifact))
                                (set@ #///.dependencies (set.from_list ///dependency.hash (list dependee)))
                                ///pom.write
                                try.assume)
               
               dependee_package (|> dependee_package
                                    (set@ #///package.origin (#///repository/origin.Remote ""))
                                    (set@ #///package.pom [dependee_pom
                                                           (|> dependee_pom (\ xml.codec encode) (\ utf8.codec encode))
                                                           #///dependency/status.Unverified]))
               depender_package (|> depender_package
                                    (set@ #///package.origin (#///repository/origin.Remote ""))
                                    (set@ #///package.pom [depender_pom
                                                           (|> depender_pom (\ xml.codec encode) (\ utf8.codec encode))
                                                           #///dependency/status.Unverified]))

               fs (file.mock (\ file.default separator))
               program (program.async (program.mock environment.empty home working_directory))]]
        (wrap (do promise.monad
                [verdict (do ///action.monad
                           [#let [console (@version.echo "")
                                  local (///repository/local.repository program fs)]
                            pre (|> ///dependency/resolution.empty
                                    (dictionary.put dependee dependee_package)
                                    (///dependency/deployment.all local))
                            post (|> (\ ///.monoid identity)
                                     (set@ #///.dependencies (set.from_list ///dependency.hash (list dependee depender)))
                                     (/.do! console local (list (///repository.mock ($///dependency/resolution.single depender_artifact depender_package)
                                                                                    []))))

                            #let [had_dependee_before!
                                  (set.member? pre dependee_artifact)

                                  lacked_depender_before!
                                  (not (set.member? pre depender_artifact))

                                  had_dependee_after!
                                  (dictionary.key? post dependee)
                                  
                                  had_depender_after!
                                  (dictionary.key? post depender)]]
                           (wrap (and had_dependee_before!
                                      lacked_depender_before!
                                      
                                      had_dependee_after!
                                      had_depender_after!)))]
                (_.cover' [/.do!]
                          (try.default false verdict)))))))