(.module:
  [library
   [lux #*
    ["_" test (#+ Test)]
    [abstract
     [monad (#+ do)]
     ["." predicate]]
    [control
     ["." try]
     [concurrency
      ["." async]]
     [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: .public test
  Test
  (<| (_.covering /._)
      (do random.monad
        [home (random.ascii/alpha 5)
         working_directory (random.ascii/alpha 5)

         dependee_artifact $///artifact.random
         depender_artifact (random.only (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)
                                (with@ #///.identity (#.Some dependee_artifact))
                                ///pom.write
                                try.trusted)
               depender_pom (|> (\ ///.monoid identity)
                                (with@ #///.identity (#.Some depender_artifact))
                                (with@ #///.dependencies (set.of_list ///dependency.hash (list dependee)))
                                ///pom.write
                                try.trusted)
               
               dependee_package (|> dependee_package
                                    (with@ #///package.origin (#///repository/origin.Remote ""))
                                    (with@ #///package.pom [dependee_pom
                                                            (|> dependee_pom (\ xml.codec encoded) (\ utf8.codec encoded))
                                                            #///dependency/status.Unverified]))
               depender_package (|> depender_package
                                    (with@ #///package.origin (#///repository/origin.Remote ""))
                                    (with@ #///package.pom [depender_pom
                                                            (|> depender_pom (\ xml.codec encoded) (\ utf8.codec encoded))
                                                            #///dependency/status.Unverified]))

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

                          .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)]]
                         (in (and had_dependee_before!
                                  lacked_depender_before!
                                  
                                  had_dependee_after!
                                  had_depender_after!)))]
              (_.cover' [/.do!]
                        (try.else false verdict)))))))