Passing self to an external method

[rkjnsn]

I have a struct Foo that I'm trying to mock with faux. One of the methods has something like this:

#[cfg_attr(test, faux::methods)]
impl Foo {
    pub async fn method(&self) {
        Bar::method(self).await; // Error: Bar::method expects &Foo, but self is &_FauxOriginal_Foo.
    }
}

Ideally, faux would do some magic here to pass Bar::method a reference to the outer &Foo enum without any code changes, but in the interim, is there any way to make this work?

[rkjnsn]

I wonder if there might be an approach that would solve both this and #14 in one go?

[nrxus]

Hm... this one is a bit tricky I am going to have to think about it a bit.

The issue is that inside the methods wrapped by faux::methods we want to be able to use any fields of the real struct (e.g., self.my_field) hence why self here is the "real" struct. But outwardly, any method will use the wrapped potentially mocked struct.

For now as a workaround, does this method need to be mocked or can it be in am impl block that is not wrapped by faux::methods?

[rkjnsn]

There are a few such methods, one if which I do need to mock for the tests I am currently looking to write. However, these methods could easily be rewritten not to access any fields directly, and they are not used internally by other methods. As such, in lieu of some clever solution that would allow this case just to work as written, I wonder if it might be sufficient to introduce an annotation that can be applied to individual methods inside a faux::methods impl block. When this attribute is applied:

• The target method would still be mocked.
• The real method would not be put on the real, renamed struct.
• Instead, it would be renamed and put as a private method on the outer, may-be-mocked struct.
• As such, self would be the type external functions are expecting and could be passed to them.
• No fields would be accessible.
• Private methods could still be called (and would be proxied to the real instance).
• However, no method without this annotation could call a method that has had it applied.

This wouldn't cover all use cases, obviously, but it would at the least suffice for the case currently in front of me.

[nrxus]

The proposed solution sadly doesn't mesh well with the implementation of mocked methods. Currently mocked methods more or less do:

struct Foo(faux::MaybeFaux<RealFoo>)

impl Foo {
    pub fn method(&self) {
        match self {
            faux::MaybeFaux::Real(r) => r.method()
           faux::MaybeFaux::Faux(f) => {
               f.call_stub(Foo::method)
           }
       }
   }
} 

struct RealFoo { /*snip fields */ }

impl RealFoo {
    pub fn method(&self) { /* snip implementation */ }
}

So as you can see there is a method named method already in the outer potentially mocked struct, and if mocked we just look for the provided stub. If it isn't mocked then we simply defer to the real implementation. What you want though, is to allow method to still be mockable, but if it isn't mocked, re-wrap it in the outer struct so it can be passed to external structs. There are ways to make your proposed solution work kind-of but I feel it'd be messy to implement, explain (document), and maintain.

What I'd love to be able to do is provide a way to go go from a reference to a real struct back to a reference of the mocked struct so you can pass sprinkle that incantation on the few places that are needed... However I don't think it is possible to go from &T -> &ContainerOf where ContainerOf is an enum until this is in stable: https://doc.rust-lang.org/nightly/unstable-book/language-features/offset-of-enum.html

Once that is merged I could implement something that says: "the real variant of field T is in offset N, hence I could get a pointer back to the enum by subtracting that offset from my address". Until then though I am not sure that's doable

That all being said, I welcome PRs so if you find a way to do your proposed solution in a way that isn't too messy or complex I'd definitely take a look

[rkjnsn]

I was imagining that something like this:

struct Foo {
    field: u32,
    // …
}

#[cfg_attr(test, faux::methods)]
impl Foo {
    pub fn method1(&self) {
        self.field += 1;
    }

    #[cfg_attr(test, faux::on_outer)]
    pub fn method2(&self) {
        Bar::method(self);
    }
}

Would be transformed into something like this:

struct Foo(faux::MaybeFaux<RealFoo>)

impl Foo {
    pub fn method1(&self) {
        match self {
            faux::MaybeFaux::Real(r) => r.method1()
            faux::MaybeFaux::Faux(f) => {
                f.call_stub(Foo::method1)
            }
        }
    }

    pub fn method2(&self) {
        match self {
            faux::MaybeFaux::Real(_) => self.real_method2()
            faux::MaybeFaux::Faux(f) => {
                f.call_stub(Foo::method2)
            }
        }
    }

    pub fn real_method2(&self) {
        Bar::method(self);
    }
} 

struct RealFoo{
    field: u32,
    // …
}

impl RealFoo {
    pub fn method1(&self) {
        self.field += 1;
    }
}

[nrxus]

That'd make it pretty confusing to anyone trying to use method2inside another method (as it wouldn't compile), which would also affect mocking of trait implementations and it is also very restrictive on what could be written inside method2.Is it technically feasible for some very specific use-case, possibly? But it'd be a pretty big hammer to have to maintain for what feels like a differently shaped nail.

In that particular case actually, if method2 could be purely defined based on public functions I go back to my original question of "does it need to be mockable" as opposed to mocking the public methods that it'd use and then implement it outside of the faux::methods attribute?

struct Foo {
    field: u32,
    // …
}

#[cfg_attr(test, faux::methods)]
impl Foo {
    pub fn method1(&self) {
        self.field += 1;
    }
}

impl Foo {
    pub fn method2(&self) {
        /* can only use methods here but can be passed to other external structs */
        Bar::method(self);
    }
}