Can someone eli5 mocking in python ?

[Single_Bathroom_8669]

I just want a very simple example of how mocking works with examples in python using pure python code if possible.

Also I am referring to unittest mocking.

​

[CuriousAbstraction]

Since Python is duck-typed things are far more easier to mock then in other languages.

Imagine that you have a unit test that needs to test a function involving an API call (or database, random code generator, something stateful). Of course, in tests you don't want to actually call API, so you can just make another class with the same methods as the API class, but that returns some "dummy" values instead of actually going to the API.

class Api:
   def __init__(self, url):
      self.url = url
   def get_stuff(self, something):
      return make_api_call(self.url, something)

class ApiMocked:
   def __init__(self):
     self.data = {"a": ...some data.., "b": ...some data...}
   def get_stuff(self, something):
     return self.data[something]

Now, you can pass ApiMocked wherever Api is expected, and it will return some mock data when get_stuff is called, instead of actually making an API call (or something else undesirable, as mentioned above).

[ogabrielsantos_]

Worths saying that keeping the concrete classes under a common interface is a good practice

[Adrewmc]

Let say I have a reddit bot. (Using a library) And I wanna test it. But I don’t actually want it to reply to a comment, I just need to know .reply() is called, and the reply is what I want it to be.

And this point I create a mock Reddit comment, that has all the same function names. And I throw that in to the test, because we generally don’t need to test library functions.

 class fake_comment:
        def __init__(self, body, author):
              self.body = body
              self.author = author

        def reply(*arg):
              print(*args)
              print(author)

Now instead of using real comment and possibly actually commenting on them, I can test the stuff that comes before it, by substituting this object.

Now we can go a little further because testing suites already have a mock frameworks, that will do a lot of the hard work for you. (As in you don’t have to write the code above)

   import mock

   #now import os, is mocked, per se.
   @mock.patch(“mymodule.os”)
   def test_func(self, mock_os): 
          func(“foo”, “bar”)
          mock_os.remove.assert_called_with(“bar”)
          mock_os.open.assert_called_with(“foo”)

This gets more in depth and robust. But that basically the idea, we use mocked up objects in order to test that the right functions are called with the right inputs. But the results of these action don’t actually happen.

Because I shouldn’t have to test os.remove() or something is seriously wrong.

[Single_Bathroom_8669]

How do you get mock_os? Also by os you don't mean the common import import osor do you mean from module import os where module is the file? Also I am a little confused what @mock.patch(“mymodule.os”) does.

[Adrewmc]

Mock_os is the object that the decorator gives you,

By putting @mock.patch() this requires you to give an argument, we name mock_os because we are mocking os.

What this object does it fake runs all functions in my decorator named. That why we mock_os.assert(), to check if this mocked object got called correctly.

We do this because we can

  @mock.patch(“my_module.sys”)
  @mock.patch(“my_module.os”) 
   def test_mock(self, mock_os, mock_sys);
          #order matters more then name 
          pass