Using Cassette

.travis.yml

@@ -4,8 +4,6 @@ os:
   - linux
   - osx
 julia:
-  - 0.6
-  - 0.7
   - 1.0
   - nightly
 env:
@@ -17,17 +15,16 @@ notifications:
 script:
   - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
   - |
-    julia --depwarn=error -e '
-      VERSION >= v"0.7.0-DEV.3656" && using Pkg
-      if VERSION >= v"0.7.0-DEV.5183" && (isfile("Project.toml") || isfile("JuliaProject.toml"))
+    julia -e '
+      using Pkg
+      if isfile("Project.toml") || isfile("JuliaProject.toml")
           Pkg.build(); Pkg.test(coverage=true)
       else
           Pkg.clone(pwd()); Pkg.build("Mocking"); Pkg.test("Mocking"; coverage=true)
       end'
 after_success:
   - |
     julia -e '
-      VERSION >= v"0.7.0-DEV.3656" && using Pkg
-      VERSION >= v"0.7.0-DEV.5183" || cd(Pkg.dir("Mocking"))
+      using Pkg
       Pkg.add("Coverage"); using Coverage
       Codecov.submit(process_folder())'

README.md

@@ -41,27 +41,21 @@ result = randdev(n)
 @test length(result) == n
 ```
 
-How could we create a test that shows the output of the function is reversed? Mocking.jl
-provides the `@mock` macro which allows package developers to temporarily overload a
-specific calls in their package. In this example we will apply `@mock` to the `open` call
-in `randdev`:
+How could we create a test that shows the output of the function is reversed?
+ Mocking.jl provides a mechanism which allows package developers to temporarily overload a
+specific calls in their package. In this example we will mock the `open` call
+in `randdev`.
+No changes are required at the call site.
 
-```julia
-using Mocking
-
-function randdev(n::Integer)
-    @mock open("/dev/urandom") do fp
-        reverse(read(fp, n))
-    end
-end
-```
 
-With the call site being marked as "mockable" we can now write a testcase which allows
-us to demonstrate the reversing behaviour within the `randdev` function:
+We just need to write a testcase which allows
+us to demonstrate the reversing behaviour within the `randdev` function.
+This is done using the `@patch` macro, to define a patch,
+which is applied to a block of code using the `apply` function.
+As shown in the example below:
 
 ```julia
 using Mocking
-Mocking.enable()  # Need to enable before we import any code using the `@mock` macro
 
 using Base.Test
 import ...: randdev
@@ -79,38 +73,22 @@ apply(patch) do
     @test randdev(n) == convert(Array{UInt8}, n:-1:1)
 end
 
-# Outside of the scope of the patched environment `@mock` is essentially a no-op
+# Outside of the scope of the patched environment behavour is
+# as it was before
 @test randdev(n) != convert(Array{UInt8}, n:-1:1)
 ```
 
 Gotchas
 -------
 
-Remember to:
-
-- use `@mock` at desired call sites
-- start julia with `--compiled-modules=no` (`--compilecache=no` for ≤0.6) or pass `force=true` to `Mocking.enable`
-- run `Mocking.enable` before importing the module(s) being tested
-
-Notes
------
-
-Mocking.jl is intended to be used for testing only and will not affect the performance of
-your code when using `@mock`. In fact the `@mock` is actually a no-op when `Mocking.enable`
-is not called. One side effect of this behaviour is that pre-compiled packages won't test
-correctly with Mocking unless you start Julia with `--compiled-modules=no` (≥0.7) or
-`--compilecache=no` (≤0.6).
-
-```
-$ julia --compilecache=no -e Pkg.test("...")
-```
+ - Remember to `using`/`import` functions before you `@patch` them.
+ - You can not mock a method that does not exist.
 
-Alternatively you can use `Mocking.enable(force=true)` to automatically disable using
-package precompilation for you (experimental). Make sure to call `enable` before the you
-importing the module you are testing.
+Mocking.jl relies heavily on [Cassette.jl](https://github.com/jrevels/Cassette.jl).
+Many issues that affect Cassette.jl will also affect Mocking.jl.
 
 
 License
 -------
 
-Mocking.jl is provided under the [MIT "Expat" License](LICENSE.md).
+Mocking.jl is provided under the [MIT "Expat" License](LICENSE.md).

REQUIRE

@@ -1,2 +1,3 @@
-julia 0.6
-Compat 0.59
+julia 1.0
+MacroTools
+Cassette

appveyor.yml

@@ -1,7 +1,5 @@
 environment:
   matrix:
-  - julia_version: 0.6
-  - julia_version: 0.7
   - julia_version: 1.0
   - julia_version: latest
 

src/Mocking.jl

@@ -1,247 +1,29 @@
 __precompile__(true)
 
 module Mocking
+using MacroTools
+using Cassette
+using Cassette: @context
 
-using Compat: @__MODULE__, hasmethod, invokelatest, undef, @info, @warn
 
 include("expr.jl")
 include("bindings.jl")
-include("options.jl")
 include("deprecated.jl")
+include("patch.jl")
+include("patchenv.jl")
+
 
 export
     # Mocking.jl
-    @patch, @mock, Patch, apply,
-    # options.jl
-    DISABLE_COMPILED_MODULES_STR, DISABLE_COMPILED_MODULES_CMD
-
-# When ENABLED is false the @mock macro is a noop.
-global ENABLED = false
-global PATCH_ENV = nothing
-
-function enable(; force::Bool=false)
-    ENABLED::Bool && return  # Abend early if enabled has already been set
-    global ENABLED = true
-    global PATCH_ENV = PatchEnv()
-
-    if compiled_modules_enabled()
-        if force
-            # Disable using compiled modules when Mocking is enabled
-            set_compiled_modules(false)
-        else
-            @warn(
-                "Mocking.jl will probably not work when $COMPILED_MODULES_FLAG is ",
-                "enabled. Please start `julia` with `$DISABLE_COMPILED_MODULES_STR` ",
-                "or alternatively call `Mocking.enable(force=true).`",
-            )
-        end
-    end
-end
-
-struct Patch
-    signature::Expr
-    body::Function
-    modules::Set
-    # translation::Dict
-
-    function Patch(signature::Expr, body::Function, translation::Dict)
-        trans = adjust_bindings(translation)
-        sig = name_parameters(absolute_signature(signature, trans))
-
-        # On VERSION >= v"0.5"
-        # modules = Set(b.args[1] for b in values(trans) if isa(b, Expr))
-        modules = Set()
-        for b in values(trans)
-            if isa(b, Expr)
-                push!(modules, b.args[1])
-            end
-        end
-
-        new(sig, body, modules)
-    end
-end
-
-# TODO: Find non-eval way to determine module locations of Types
-# evaling in the @patch scope seems to be problematic for pre-compliation
-# first(methods(x)).sig.types[2:end]
-
-# We can use the @patch macro to create a list of bindings used then pass that
-# in as an array into Patch. At runtime the types and function names will be fully
-# qualified
-
-# We can support optional parameters and keywords by using generic functions on
-# 0.4
-
-function convert(::Type{Expr}, p::Patch)
-    exprs = Expr[]
+    @patch, Patch, apply,
+    # deprecated.jl
+    @mock
 
-    # Generate imports for all required modules
-    for m in p.modules
-        bindings = splitbinding(m)
 
-        :Main in bindings && error("Mocking cannot handle bindings from Main.")
-
-        for i in 1:length(bindings)
-            import_expr = if VERSION > v"0.7.0-DEV.3187"
-                Expr(:import, Expr(:., bindings[1:i]...))
-            else
-                Expr(:import, bindings[1:i]...)
-            end
-            push!(exprs, import_expr)
-        end
-    end
-
-    # Generate the new method which will call the user's patch function. We need to perform
-    # this call instead of injecting the body expression to support closures.
-    sig, body = p.signature, p.body
-    params = call_parameters(sig)
-    push!(exprs, Expr(:(=), sig, Expr(:block, Expr(:call, body, params...))))
-
-    return Expr(:block, exprs...)
-end
-
-macro patch(expr::Expr)
-    if expr.head == :function
-        name = expr.args[1].args[1]
-        params = expr.args[1].args[2:end]
-        body = expr.args[2]
-
-    # Short-form function syntax
-    elseif expr.head == :(=) && expr.args[1].head == :call
-        name = expr.args[1].args[1]
-        params = expr.args[1].args[2:end]
-        body = expr.args[2]
-
-    # Anonymous function syntax
-    # elseif expr.head == :(->)
-        # TODO: Determine how this could be supported
-    else
-        throw(ArgumentError("expression is not a function definition"))
-    end
-
-    signature = Expr(:call, name, params...)
-
-    # Determine the bindings used in the signature
-    bindings = Bindings(signature)
-
-    # Need to evaluate the body of the function in the context of the `@patch` macro in
-    # order to support closures.
-    # func = Expr(:(->), Expr(:tuple, params...), body)
-    func = Expr(:(=), Expr(:call, gensym(), params...), body)
-
-    # Generate a translation between the external bindings and the runtime types and
-    # functions. The translation will be used to revise all bindings to be absolute.
-    translations = [Expr(:call, :(=>), QuoteNode(b), b) for b in bindings.external]
-
-    return esc(:(Mocking.Patch( $(QuoteNode(signature)), $func, Dict($(translations...)) )))
-end
-
-struct PatchEnv
-    mod::Module
-    debug::Bool
-
-    function PatchEnv(debug::Bool=false)
-        # Be careful not to call this code during pre-compilation otherwise we'll see the
-        # warning: "incremental compilation may be broken for this module"
-        m = Core.eval(Mocking, :(module $(gensym()) end))
-        new(m, debug)
-    end
-end
-
-function PatchEnv(patches::Array{Patch}, debug::Bool=false)
-    pe = PatchEnv(debug)
-    apply!(pe, patches)
-    return pe
-end
-
-function PatchEnv(patch::Patch, debug::Bool=false)
-    pe = PatchEnv(debug)
-    apply!(pe, patch)
-    return pe
-end
-
-function apply!(pe::PatchEnv, p::Patch)
-    Core.eval(pe.mod, convert(Expr, p))
-end
-
-function apply!(pe::PatchEnv, patches::Array{Patch})
-    for p in patches
-        apply!(pe, p)
-    end
-end
-
-function apply(body::Function, pe::PatchEnv)
-    original_pe = get_active_env()
-    set_active_env(pe)
-    try
-        return body()
-    finally
-        set_active_env(original_pe)
-    end
-end
-
-function apply(body::Function, patches::Array{Patch}; debug::Bool=false)
-    apply(body, PatchEnv(patches, debug))
-end
-function apply(body::Function, patch::Patch; debug::Bool=false)
-    apply(body, PatchEnv(patch, debug))
-end
 
 function ismocked(pe::PatchEnv, func_name::Symbol, args::Tuple)
-    if isdefined(pe.mod, func_name)
-        func = Core.eval(pe.mod, func_name)
-        types = map(arg -> isa(arg, Type) ? Type{arg} : typeof(arg), args)
-        exists = hasmethod(func, types)
-
-        if pe.debug
-            @info("calling $func_name$(types)")
-            if exists
-                m = first(methods(func, types))
-                @info("executing mocked function: $m")
-            else
-                m = first(methods(Core.eval(func_name), types))
-                @info("executing original function: $m")
-            end
-        end
-
-        return exists
-    end
-    return false
+    # TODO: redefine this in terms of `methodswith(pe.ctx, Cassette.execute...)`
+    # If required
+    error("`ismocked` is not implemented")
 end
-
-set_active_env(pe::PatchEnv) = (global PATCH_ENV = pe)
-get_active_env() = PATCH_ENV::PatchEnv
-
-macro mock(expr)
-    isa(expr, Expr) || error("argument is not an expression")
-    expr.head == :do && (expr = rewrite_do(expr))
-    expr.head == :call || error("expression is not a function call")
-    ENABLED::Bool || return esc(expr)  # @mock is a no-op when Mocking is not ENABLED
-
-    func = expr.args[1]
-    func_name = QuoteNode(func)
-    args = filter(x -> !Mocking.iskwarg(x), expr.args[2:end])
-    kwargs = extract_kwargs(expr)
-
-    env_var = gensym("env")
-    args_var = gensym("args")
-
-    # Note: The fix to Julia issue #265 (PR #17057) introduced changes where no compiled
-    # calls could be made to functions compiled afterwards. Since the `Mocking.apply`
-    # do-block syntax compiles the body of the do-block function before evaluating the
-    # "outer" function this means our patch functions will be compiled after the "inner"
-    # function.
-    result = quote
-        local $env_var = Mocking.get_active_env()
-        local $args_var = tuple($(args...))
-        if Mocking.ismocked($env_var, $func_name, $args_var)
-            Mocking.invokelatest($env_var.mod.$func, $args_var...; $(kwargs...))
-        else
-            $func($args_var...; $(kwargs...))
-        end
-    end
-
-    return esc(result)
-end
-
 end # module