Achieve Goals Online

An Introduction to Mocking in Python

May 05, 2017

How to Run Unit Tests Without Testing Your Patience

More often than not, the software we write directly interacts with what we would label as “dirty” services. In layman’s terms: services that are crucial to our application, but whose interactions have intended but undesired side-effects—that is, undesired in the context of an autonomous test run.

For example: perhaps we’re writing a social app and want to test out our new ‘Post to Facebook feature’, but don’t want to actually post to Facebook every time we run our test suite.

The Python unittest library includes a subpackage named unittest.mock—or if you declare it as a dependency, simply mock—which provides extremely powerful and useful means by which to mock and stub out these undesired side-effects.

Source | http://www.toptal.com/python/an-introduction-to-mocking-in-python

Note: mock is newly included in the standard library as of Python 3.3; prior distributions will have to use the Mock library downloadable via PyPI.

Fear System Calls

To give you another example, and one that we’ll run with for the rest of the article, consider system calls. It’s not difficult to see that these are prime candidates for mocking: whether you’re writing a script to eject a CD drive, a web server which removes antiquated cache files from /tmp, or a socket server which binds to a TCP port, these calls all feature undesired side-effects in the context of your unit-tests.

As a developer, you care more that your library successfully called the system function for ejecting a CD as opposed to experiencing your CD tray open every time a test is run.

As a developer, you care more that your library successfully called the system function for ejecting a CD (with the correct arguments, etc.) as opposed to actually experiencing your CD tray open every time a test is run. (Or worse, multiple times, as multiple tests reference the eject code during a single unit-test run!)

Likewise, keeping your unit-tests efficient and performant means keeping as much “slow code” out of the automated test runs, namely filesystem and network access.

For our first example, we’ll refactor a standard Python test case from original form to one using mock. We’ll demonstrate how writing a test case with mocks will make our tests smarter, faster, and able to reveal more about how the software works.

A Simple Delete Function

We all need to delete files from our filesystem from time to time, so let’s write a function in Python which will make it a bit easier for our scripts to do so.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os

def rm(filename):
    os.remove(filename)

Obviously, our rm method at this point in time doesn’t provide much more than the underlying os.remove method, but our codebase will improve, allowing us to add more functionality here.

Let’s write a traditional test case, i.e., without mocks:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from mymodule import rm

import os.path
import tempfile
import unittest

class RmTestCase(unittest.TestCase):

    tmpfilepath = os.path.join(tempfile.gettempdir(), "tmp-testfile")

    def setUp(self):
        with open(self.tmpfilepath, "wb") as f:
            f.write("Delete me!")
        
    def test_rm(self):
        # remove the file
        rm(self.tmpfilepath)
        # test that it was actually removed
        self.assertFalse(os.path.isfile(self.tmpfilepath), "Failed to remove the file.")

Our test case is pretty simple, but every time it is run, a temporary file is created and then deleted. Additionally, we have no way of testing whether our rm method properly passes the argument down to the os.remove call. We can assume that it does based on the test above, but much is left to be desired.

Refactoring with Mocks

Let’s refactor our test case using mock:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from mymodule import rm

import mock
import unittest

class RmTestCase(unittest.TestCase):
    
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os):
        rm("any path")
        # test that rm called os.remove with the right parameters
        mock_os.remove.assert_called_with("any path")

With these refactors, we have fundamentally changed the way that the test operates. Now, we have an insider, an object we can use to verify the functionality of another.

Potential Pitfalls

One of the first things that should stick out is that we’re using the mock.patch method decorator to mock an object located at mymodule.os, and injecting that mock into our test case method. Wouldn’t it make more sense to just mock os itself, rather than the reference to it at mymodule.os?

Well, Python is somewhat of a sneaky snake when it comes to imports and managing modules. At runtime, the mymodule module has its own os which is imported into its own local scope in the module. Thus, if we mock os, we won’t see the effects of the mock in the mymodule module.

The mantra to keep repeating is this:

Mock an item where it is used, not where it came from.

If you need to mock the tempfile module for myproject.app.MyElaborateClass, you probably need to apply the mock to myproject.app.tempfile, as each module keeps its own imports.

With that pitfall out of the way, let’s keep mocking.

Adding Validation to ‘rm’

The rm method defined earlier is quite oversimplified. We’d like to have it validate that a path exists and is a file before just blindly attempting to remove it. Let’s refactor rm to be a bit smarter:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import os.path

def rm(filename):
    if os.path.isfile(filename):
        os.remove(filename)

Great. Now, let’s adjust our test case to keep coverage up.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from mymodule import rm

import mock
import unittest

class RmTestCase(unittest.TestCase):
    
    @mock.patch('mymodule.os.path')
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os, mock_path):
        # set up the mock
        mock_path.isfile.return_value = False
        
        rm("any path")
        
        # test that the remove call was NOT called.
        self.assertFalse(mock_os.remove.called, "Failed to not remove the file if not present.")
        
        # make the file 'exist'
        mock_path.isfile.return_value = True
        
        rm("any path")
        
        mock_os.remove.assert_called_with("any path")

Our testing paradigm has completely changed. We now can verify and validate internal functionality of methods without any side-effects.

File-Removal as a Service

So far, we’ve only been working with supplying mocks for functions, but not for methods on objects or cases where mocking is necessary for sending parameters. Let’s cover object methods first.

We’ll begin with a refactor of the rm method into a service class. There really isn’t a justifiable need, per se, to encapsulate such a simple function into an object, but it will at the very least help us demonstrate key concepts in mock. Let’s refactor:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import os.path

class RemovalService(object):
    """A service for removing objects from the filesystem."""

    def rm(filename):
        if os.path.isfile(filename):
            os.remove(filename)

You’ll notice that not much has changed in our test case:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from mymodule import RemovalService

import mock
import unittest

class RemovalServiceTestCase(unittest.TestCase):
    
    @mock.patch('mymodule.os.path')
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os, mock_path):
        # instantiate our service
        reference = RemovalService()
        
        # set up the mock
        mock_path.isfile.return_value = False
        
        reference.rm("any path")
        
        # test that the remove call was NOT called.
        self.assertFalse(mock_os.remove.called, "Failed to not remove the file if not present.")
        
        # make the file 'exist'
        mock_path.isfile.return_value = True
        
        reference.rm("any path")
        
        mock_os.remove.assert_called_with("any path")

Great, so we now know that the RemovalService works as planned. Let’s create another service which declares it as a dependency:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import os.path

class RemovalService(object):
    """A service for removing objects from the filesystem."""

    def rm(self, filename):
        if os.path.isfile(filename):
            os.remove(filename)
            

class UploadService(object):

    def __init__(self, removal_service):
        self.removal_service = removal_service
        
    def upload_complete(self, filename):
        self.removal_service.rm(filename)

Since we already have test coverage on the RemovalService, we’re not going to validate internal functionality of the rm method in our tests of UploadService. Rather, we’ll simply test (without side-effects, of course) that UploadService calls the RemovalService.rm method, which we know “just works™” from our previous test case.

There are two ways to go about this:

Mock out the RemovalService.rm method itself.
Supply a mocked instance in the constructor of UploadService.

As both methods are often important in unit-testing, we’ll review both.

Option 1: Mocking Instance Methods

The mock library has a special method decorator for mocking object instance methods and properties, the @mock.patch.object decorator:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from mymodule import RemovalService, UploadService

import mock
import unittest

class RemovalServiceTestCase(unittest.TestCase):
    
    @mock.patch('mymodule.os.path')
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os, mock_path):
        # instantiate our service
        reference = RemovalService()
        
        # set up the mock
        mock_path.isfile.return_value = False
        
        reference.rm("any path")
        
        # test that the remove call was NOT called.
        self.assertFalse(mock_os.remove.called, "Failed to not remove the file if not present.")
        
        # make the file 'exist'
        mock_path.isfile.return_value = True
        
        reference.rm("any path")
        
        mock_os.remove.assert_called_with("any path")
      
      
class UploadServiceTestCase(unittest.TestCase):

    @mock.patch.object(RemovalService, 'rm')
    def test_upload_complete(self, mock_rm):
        # build our dependencies
        removal_service = RemovalService()
        reference = UploadService(removal_service)
        
        # call upload_complete, which should, in turn, call `rm`:
        reference.upload_complete("my uploaded file")
        
        # check that it called the rm method of any RemovalService
        mock_rm.assert_called_with("my uploaded file")
        
        # check that it called the rm method of _our_ removal_service
        removal_service.rm.assert_called_with("my uploaded file")

Great! We’ve validated that the UploadService successfully calls our instance’s rm method. Notice anything interesting in there? The patching mechanism actually replaced the rm method of all RemovalService instances in our test method. That means that we can actually inspect the instances themselves. If you want to see more, try dropping in a breakpoint in your mocking code to get a good feel for how the patching mechanism works.

Pitfall: Decorator Order

When using multiple decorators on your test methods, order is important, and it’s kind of confusing. Basically, when mapping decorators to method parameters, work backwards. Consider this example:

    @mock.patch('mymodule.sys')
    @mock.patch('mymodule.os')
    @mock.patch('mymodule.os.path')
    def test_something(self, mock_os_path, mock_os, mock_sys):
        pass

Notice how our parameters are matched to the reverse order of the decorators? That’s partly because of the way that Python works. With multiple method decorators, here’s the order of execution in pseudocode:

patch_sys(patch_os(patch_os_path(test_something)))

Since the patch to sys is the outermost patch, it will be executed last, making it the last parameter in the actual test method arguments. Take note of this well and use a debugger when running your tests to make sure that the right parameters are being injected in the right order.

Option 2: Creating Mock Instances

Instead of mocking the specific instance method, we could instead just supply a mocked instance to UploadService with its constructor. I prefer option 1 above, as it’s a lot more precise, but there are many cases where option 2 might be efficient or necessary. Let’s refactor our test again:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from mymodule import RemovalService, UploadService

import mock
import unittest

class RemovalServiceTestCase(unittest.TestCase):
    
    @mock.patch('mymodule.os.path')
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os, mock_path):
        # instantiate our service
        reference = RemovalService()
        
        # set up the mock
        mock_path.isfile.return_value = False
        
        reference.rm("any path")
        
        # test that the remove call was NOT called.
        self.assertFalse(mock_os.remove.called, "Failed to not remove the file if not present.")
        
        # make the file 'exist'
        mock_path.isfile.return_value = True
        
        reference.rm("any path")
        
        mock_os.remove.assert_called_with("any path")
      
      
class UploadServiceTestCase(unittest.TestCase):

    def test_upload_complete(self, mock_rm):
        # build our dependencies
        mock_removal_service = mock.create_autospec(RemovalService)
        reference = UploadService(mock_removal_service)
        
        # call upload_complete, which should, in turn, call `rm`:
        reference.upload_complete("my uploaded file")
        
        # test that it called the rm method
        mock_removal_service.rm.assert_called_with("my uploaded file")

In this example, we haven’t even had to patch any functionality, we simply create an auto-spec for the RemovalService class, and then inject this instance into our UploadService to validate the functionality.

The mock.create_autospec method creates a functionally equivalent instance to the provided class. What this means, practically speaking, is that when the returned instance is interacted with, it will raise exceptions if used in illegal ways. More specifically, if a method is called with the wrong number of arguments, an exception will be raised. This is extremely important as refactors happen. As a library changes, tests break and that is expected. Without using an auto-spec, our tests will still pass even though the underlying implementation is broken.

Pitfall: The `mock.Mock` and `mock.MagicMock` Classes

The mock library also includes two important classes upon which most of the internal functionality is built upon: [mock.Mock](http://www.voidspace.org.uk/python/mock/mock.html) and mock.MagicMock. When given a choice to use a mock.Mock instance, a mock.MagicMock instance, or an auto-spec, always favor using an auto-spec, as it helps keep your tests sane for future changes. This is because mock.Mock and mock.MagicMock accept all method calls and property assignments regardless of the underlying API. Consider the following use case:

class Target(object):
    def apply(value):
        return value

def method(target, value):
    return target.apply(value)

We can test this with a mock.Mock instance like this:

class MethodTestCase(unittest.TestCase):

    def test_method(self):
        target = mock.Mock()

        method(target, "value")

        target.apply.assert_called_with("value")

This logic seems sane, but let’s modify the Target.apply method to take more parameters:

class Target(object):
    def apply(value, are_you_sure):
        if are_you_sure:
            return value
        else:
            return None

Re-run your test, and you’ll find that it still passes. That’s because it isn’t built against your actual API. This is why you should always use the create_autospec method and the autospec parameter with the @patch and @patch.object decorators.

Real-World Example: Mocking a Facebook API Call

To finish up, let’s write a more applicable real-world example, one which we mentioned in the introduction: posting a message to Facebook. We’ll write a nice wrapper class and a corresponding test case.

import facebook

class SimpleFacebook(object):
    
    def __init__(self, oauth_token):
        self.graph = facebook.GraphAPI(oauth_token)

    def post_message(self, message):
        """Posts a message to the Facebook wall."""
        self.graph.put_object("me", "feed", message=message)

Here’s our test case, which checks that we post the message without actually posting the message:

import facebook
import simple_facebook
import mock
import unittest

class SimpleFacebookTestCase(unittest.TestCase):
    
    @mock.patch.object(facebook.GraphAPI, 'put_object', autospec=True)
    def test_post_message(self, mock_put_object):
        sf = simple_facebook.SimpleFacebook("fake oauth token")
        sf.post_message("Hello World!")

        # verify
        mock_put_object.assert_called_with(message="Hello World!")

As we’ve seen so far, it’s really simple to start writing smarter tests with mock in Python.

Conclusion

Python’s mock library, if a little confusing to work with, is a game-changer for unit-testing. We’ve demonstrated common use-cases for getting started using mock in unit-testing, and hopefully this article will help Python developers overcome the initial hurdles and write excellent, tested code.

For more information visit | www.toptal.com

Entertainment

Amazing science facts that will blow your mind

May 05, 2017

Science is an integral part of our everyday life. Science is a fascinating subject with many amazing things to learn and discover. Today, let’s explore the world of science to discover a variety of fascinating and fun scientific facts that you probably are unaware of.

Why aren’t there that many people into science? Personally, I believe it has something to do with how it’s being communicated and, not least, how it’s being taught in school.

With this in mind, here are just ten amazing things that I’ve come to learn thanks to the progress of science. It’s this sort of knowledge that’s inspired me to learn more every day and it’s my deepest hope that something similar might happen to you as well. This list is much too short though, so I’m counting on you to keep it growing by adding your own science facts in the comments section

Babies have around 100 more bones than adults

Many of a baby’s bones fuse together as they grow-Babies have about 300 bones at birth, with cartilage between many of them. This extra flexibility helps them pass through the birth canal and also allows for rapid growth. With age, many of the bones fuse, leaving 206 bones that make up an average adult skeleton.

There is enough DNA in an average person’s body to stretch from the sun to Pluto and back — 17 times

The human genome, the genetic code in each human cell, contains 23 DNA molecules each containing from 500 thousand to 2.5 million nucleotide pairs. DNA molecules of this size are 1.7 to 8.5 cm long when uncoiled, or about 5 cm on average. There are about 37 trillion cells in the human body and if you’d uncoil the entire DNA encased in each cell and put them end to end, then these would sum to a total length of 2×10¹⁴meters or enough for 17 Pluto roundtrips (1.2×10¹³ meters/Pluto roundtrip).

Stomach acid is strong enough to dissolve razor blades

Your stomach lining entirely renews itself every four days-Your stomach digests food thanks to highly corrosive hydrochloric acid with a pH of 2 to 3. This acid also attacks your stomach lining, which protects itself by secreting an alkali bicarbonate solution. The lining still needs to be replaced continually, and it entirely renews itself every four days

The average human body carries ten times more bacterial cells than human cells

It’s funny how we compulsively wash our hands, spray our countertops and grimace when someone sneezes near us—in fact, we do everything we can to avoid unnecessary encounters with the germ world. The truth of the matter is that each and every one of us is a walking petri dish! All the bacteria living inside you would fill a half-gallon jug or 10 times more bacterial cells in your body than human cells, according to Carolyn Bohach, a microbiologist at the University of Idaho. Don’t worry, though. Most of these bacteria are helpful; in fact, we couldn’t survive without them.

For one thing, bacteria produce chemicals that help us harness energy and nutrients from our food. Germ-free rodents have to consume nearly a third more calories than normal rodents to maintain their body weight, and when the same animals were later given a dose of bacteria, their body fat levels spiked, even if they didn’t eat any more than they had before. The gut bacteria is also very important to maintaining immunity.

It can take a photon 40,000 years to travel from the core of the sun to its surface, but only 8 minutes to travel the rest of the way to Earth

Photon travels, on average, a particular distance d before being briefly absorbed and released by an atom, which scatters it in a new random direction. From the core to the sun’s surface (696,000 kilometers) where it can escape into space, a photon needs to make a huge number of drunken jumps. The calculation is a little tricky, but the conclusion is that a photon takes between many thousands and many millions of years to drunkenly wander to the surface of the Sun. In a way, the light that reaches us today is energy produced maybe millions of years ago. Amazing!

In 2.3 billion years it will be too hot for life to exist on Earth

Our planet will eventually become a vast desert similar to Mars today.

Over the coming hundreds of millions of years, the Sun will continue to get progressively brighter and hotter. In just over 2 billion years, temperatures will be high enough to evaporate our oceans, making life on Earth impossible. Our planet will become a vast desert similar to Mars today. As it expands into a red giant in the following few billion years, scientists predict that the Sun will finally engulf Earth altogether, spelling the definite end for our planet.

At over 2000 kilometers long, The Great Barrier Reef is the largest living structure on Earth

Coral reefs consist of huge numbers of individual coral polyps – soft-bodied, invertebrate animals – linked by tissue. The Great Barrier Reef is an interlinked system of about 3000 reefs and 900 coral islands, divided by narrow passages, just beneath the surface of the Coral Sea.Spanning more than 2000 km and covering an area of some 350 000 sq km, it is the largest living structure on Earth and the only one visible from space. But this fragile coral colony is beginning to crumble, battered by the effects of climate change, pollution, and manmade disasters.

There are 8 times as many atoms in a teaspoonful of water as there are teaspoonfuls of water in the Atlantic ocean

A teaspoon of water (about 5 mL) contains 2×10²³ water molecules, but each water molecule is comprised of 3 atoms: two hydrogen and one oxygen. Moreover, if you’d laid down end to end each water molecule from a teaspoon full you’d end up with a length of 50 billion km or 10 times the width of our solar system.

The average person walks the equivalent of five times around the world in a lifetime

The average moderately active person takes around 7,500 step/day. If you maintain that daily average and live until 80 years of age, you’ll have walked about 216,262,500 steps in your lifetime. Doing the math; the average person with the average stride living until 80 will walk a distance of around 110,000 miles. Which is the equivalent of walking about 5 times around the Earth, right on the equator.

When Helium is cooled to almost absolute zero (-460°F or -273°C), the lowest temperature possible, it becomes a liquid with surprising properties: it flows against gravity and will start running up and over the lip of a glass container!

We all know helium as a gas for blowing up balloons and making people talk like chipmunks, but what most people don’t know is that it comes in two distinct liquid states, one of which is borderline creepy. When helium is just a few degrees below its boiling point of –452 degrees Fahrenheit (–269 degrees Celsius) it will suddenly be able to do things that other fluids can’t, like dribble through molecule-thin cracks, climb up and over the sides of a dish, and remain motionless when its container is spun. No longer a mere liquid, the helium has become a superfluid—a liquid that flows without friction.

“If you set [down] a cup with a liquid circulating around and you come back 10 minutes later, of course, it’s stopped moving,” says John Beamish, an experimental physicist at the University of Alberta in Edmonton. Atoms in the liquid will collide with one another and slow down. “But if you did that with helium at low temperature and came back a million years later,” he says, “it would still be moving.

If Betelgeuse would explode transiting from the red supergiant stage to supernova then our sky would light continuously for two months. It can happen anytime, within a couple of thousand years, tomorrow or even now

Betelgeuse lies some 430 light-years from Earth. Yet it’s already one of the brightest stars in Earth’s sky. The reason is that Betelgeuse is a supergiant star – the largest kind of stars in the Universe. Betelgeuse has a luminosity about 10,000 times that of the Sun and its radius is calculated to be about 370 times that of the sun. If it were positioned at the center of our sun, its radius would extend out past the orbit of Mars. Because it’s near the end of its lifetime, Betelgeuse is likely to explode into a supernova.

An individual blood cell takes about 60 seconds to make a complete circuit of the body

You have about 5 litres of blood in your body (at least most people do) and the average heart pumps about 70 ml of blood out with each beat. Also, a healthy heart beats around 70 times a minute. So, if you multiply the amount of blood that the heart can pump by the number of beats in a minute, you actually get about 4.9 litres of blood, which is almost your whole body’s worth of blood. In just a minute, the hearts pumps the entire blood volume around your body.

The known universe is made up of 50,000,000,000 galaxies. There are between 100,000,000,000 and 1,000,000,000,000 stars in a normal galaxy. In the Milky Way alone there might be as many 100 billion Earth-like planets. Still think you’re alone?

Impress your friends with these incredible facts about the world around us.

Sources- www.nearscience.com

Smart Phones

Huawei P10 - What you'll get with this new technological device!

May 05, 2017

Huawei has launched their latest flagship smartphone the Huawei P10, last month. This smartphone comes in two sizes, Huawei P10 has 5.18 inch 1080p display, and also there is a larger model which is Huawei P10 Plus which has a 5.5 inch screen.

As usual they have added a volume rocker and an unlock button on the side, and it has a type C USB port on the bottom. And it has a home button which will has a built in finger print scanner.

Both the P10 and P10 plus are powered by Huaweis own OctaCore Kirin 960 processor, which you have seen in other huawei devices. And this processor has a decent speed that we can be pleased of.

Smaller P10 has a 4GB of RAM with a 64GB of storage. and the larger P10 Plus comes with a 6GB of RAM and 128GB of storage.

On the back of the phone it has LEICA branded dual camera system which we have seen in previous huawei P9 device. This time it has got a number of cool features, including a portrait mode, that keep the foreground in focus while blur out the background. And there is also an improved front facing camera and huawei says it is optimized for selfies.

When we look at the design you'll see that the design is so close to the iPhone. But it is a good thing. It has got a discreet antenna line at the bottom, smooth round edges which will feel good on your hand, and also not like iPhone it's available in many colors including blue and green.

With the Huawei P10 and P10 plus, huawei introduced a new finish on the back that it cause hyper diamond cut. It means that the back metal will give a bit of a texture to the phone. And also it is more resistance to the scratches and also less slippery in your hand.

The phone is running on huwei's new Android skin, and comes with a number of new software features. And the most interesting of these is probably the machine learning algorithm which analyze how you use the phone all the time and prioritize the apps which accepts most.

Overall this device is much closer to the huawei devices before. But it is not revolutionary. P10 will cost around $685 while the P10 Plus will cost around $740.

This is all for this article, stay tuned with us and we'll bring you latest news about latest gadgets and technologies.

Watch the un-boxing video below

An Introduction to Mocking in Python

How to Run Unit Tests Without Testing Your Patience

A Simple Delete Function

Refactoring with Mocks

Potential Pitfalls

Mock an item where it is used, not where it came from.

Adding Validation to ‘rm’

File-Removal as a Service

Option 1: Mocking Instance Methods

Pitfall: Decorator Order

Option 2: Creating Mock Instances

Pitfall: The `mock.Mock` and `mock.MagicMock` Classes

Real-World Example: Mocking a Facebook API Call

Conclusion

Amazing science facts that will blow your mind

Babies have around 100 more bones than adults

There is enough DNA in an average person’s body to stretch from the sun to Pluto and back — 17 times

Stomach acid is strong enough to dissolve razor blades

The average human body carries ten times more bacterial cells than human cells

It can take a photon 40,000 years to travel from the core of the sun to its surface, but only 8 minutes to travel the rest of the way to Earth

In 2.3 billion years it will be too hot for life to exist on Earth

At over 2000 kilometers long, The Great Barrier Reef is the largest living structure on Earth

There are 8 times as many atoms in a teaspoonful of water as there are teaspoonfuls of water in the Atlantic ocean

The average person walks the equivalent of five times around the world in a lifetime

When Helium is cooled to almost absolute zero (-460°F or -273°C), the lowest temperature possible, it becomes a liquid with surprising properties: it flows against gravity and will start running up and over the lip of a glass container!

If Betelgeuse would explode transiting from the red supergiant stage to supernova then our sky would light continuously for two months. It can happen anytime, within a couple of thousand years, tomorrow or even now

An individual blood cell takes about 60 seconds to make a complete circuit of the body

The known universe is made up of 50,000,000,000 galaxies. There are between 100,000,000,000 and 1,000,000,000,000 stars in a normal galaxy. In the Milky Way alone there might be as many 100 billion Earth-like planets. Still think you’re alone?

Huawei P10 - What you'll get with this new technological device!

Press

recent posts

Sponsored

Sponsored

Popular Posts

Labels

Sponsored

Blog Archive

An Introduction to Mocking in Python

How to Run Unit Tests Without Testing Your Patience

A Simple Delete Function

Refactoring with Mocks

Potential Pitfalls

Mock an item where it is used, not where it came from.

Adding Validation to ‘rm’

File-Removal as a Service

Option 1: Mocking Instance Methods

Pitfall: Decorator Order

Option 2: Creating Mock Instances

Pitfall: The mock.Mock and mock.MagicMock Classes

Real-World Example: Mocking a Facebook API Call

Conclusion

Amazing science facts that will blow your mind

Babies have around 100 more bones than adults

There is enough DNA in an average person’s body to stretch from the sun to Pluto and back — 17 times

Stomach acid is strong enough to dissolve razor blades

The average human body carries ten times more bacterial cells than human cells

It can take a photon 40,000 years to travel from the core of the sun to its surface, but only 8 minutes to travel the rest of the way to Earth

In 2.3 billion years it will be too hot for life to exist on Earth

At over 2000 kilometers long, The Great Barrier Reef is the largest living structure on Earth

There are 8 times as many atoms in a teaspoonful of water as there are teaspoonfuls of water in the Atlantic ocean

The average person walks the equivalent of five times around the world in a lifetime

When Helium is cooled to almost absolute zero (-460°F or -273°C), the lowest temperature possible, it becomes a liquid with surprising properties: it flows against gravity and will start running up and over the lip of a glass container!

If Betelgeuse would explode transiting from the red supergiant stage to supernova then our sky would light continuously for two months. It can happen anytime, within a couple of thousand years, tomorrow or even now

An individual blood cell takes about 60 seconds to make a complete circuit of the body

The known universe is made up of 50,000,000,000 galaxies. There are between 100,000,000,000 and 1,000,000,000,000 stars in a normal galaxy. In the Milky Way alone there might be as many 100 billion Earth-like planets. Still think you’re alone?

Huawei P10 - What you'll get with this new technological device!

Press

recent posts

Sponsored

Sponsored

Popular Posts

Labels

Sponsored

Blog Archive

Pitfall: The `mock.Mock` and `mock.MagicMock` Classes