Test for import from weaker code inspector

test.rkt

#lang racket

(let ()
  (define work-dir (make-temporary-file "deputy-check-~a" 'directory))
  
  (define m '(module m racket/base
               (provide m)
               (define (m) '(this is m))))

  (define n '(module n racket/base
               (require "am.rkt")
               (m)))

  (define (make e f)
    (parameterize ([current-directory work-dir]
                   [current-load-relative-directory work-dir])
      (define c (parameterize ([current-namespace  (make-base-namespace)])
                  (compile e)))
      (call-with-output-file*
       f
       #:exists 'truncate
       (lambda (o)
         (write c o)))))

  (make m "am.rkt")
  (make n "an.rkt")

  (parameterize ([current-namespace  (make-base-namespace)])
    (parameterize ([current-code-inspector  (make-inspector)])
      (parameterize ([current-module-declare-name
                      (make-resolved-module-path
                       (build-path work-dir "am.rkt"))])
        (eval m)))
    ;; attempt to import from a module with a weaker code inspector
    (with-handlers ([exn:fail? (lambda (exn)
                                 (unless (regexp-match? "weaker code inspector"
                                                        (exn-message exn))
                                   (error "failed")))])
      (dynamic-require (build-path work-dir "an.rkt") #f)
      (error "oops")))

  (delete-directory/files work-dir))