Python OOP – Splitting a Single Class into Multiple Classes

classobject-orientedpythonselenium

I am writing automated test scripts with Selenium Webdriver (Python) and I try to follow the correct programming practices, specifically the Object Oriented methodologies, where possible.

At the moment, I represent every test scenario as a single Class. That class is basically has the following structure:

Imports (Selenium modules as well as Python stuff)
Logging configuration
Class definition that includes the below:
- Driver Instance initialization
- Specific test scenario variables
- Generic methods (some wrappers I created that are used in multiple testing scenarios)
- Specific application methods

So that's something like that:

imports
logging

class AppName(object):
    def __init__(self):
        self.driver = webdriver.Chrome()

        self.localAppVar = "..."
        ...

    def genericFunction(self):
        #This is a generic function that is going to be used in many other test scenarios as well as in this one

    def specificAppFunction(self):
        #This is a specific application function. This function is only relevant withing this test. This function will use "genericFunction" internally.

app = AppName() #Initialize an AppName object
app.specificAppFunction()

...

What I would like to do is to separate the above Class into 2 new Classes and a launcher file:

Generic functions Class. This one will define the driver object as well as all generic functions that are going to be used by multiple tests.
Specific functions Class. This one will contain the application specific function that are irrelevant for other applications.
Launcher file that will initialize\instantiate the above mentioned classes and will control the scenario on a higher level. (kind of main in C if you like).

The above idea makes sense to me but I am a bit confused about the practical approach. How should that be implemented properly?

I was thinking about following options:

Creating a generic class instance withing a specific application class.
Make the generic class a base class and then inherit it by specific application class.

I am not sure about pros and cons of both approaches and currently a bit stuck with the implementation. It will be great if someone could give me some insight on how such task should be implemented.

Hopefully my question is clear enough. If it's not, please comment and I will elaborate or/and edit.

Best Answer

Generic functions should not go into classes. Python is not Java, it does not require pure functions to live inside classes. Only use classes if you want to store state of some kind. Put the functions into a standalone utility module, and import that into the module that contains your test classes.

Related Solutions

Selenium – Best Use Cases for Selenium Testing

Unit testing is just one of the multiple types of testing. Basically, you'll find three types of tests:

Unit tests.

Each of those tests ensure that a tiny piece of application is working as expected. For example, a unit test will ensure that if, on an e-commerce website, I create an instance of a Product class with a price inferior to zero, an exception will be thrown.
Integration tests.

This is similar to unit tests, but with a larger scope. Once you created the blocks of the application and test them, you start to assemble them into something bigger. Integration tests ensure that those blocks work as expected when assembled.

For example, your product management block was unit tested to prevent creating products with a price inferior to zero, and your administrative interface block was tested to prevent invalid values from being entered by the users, but what about those two blocks interacting one with another?
System tests.

The scope of those tests is even larger. While integration tests are more concerned with interfaces between two blocks, system tests are run on the whole system.

For example, what happens when two administrators attempt to modify the product with the same ID, while the primary database goes down for a few seconds, letting the mirror database to handle the operation?

To complicate things a bit, there are additional types of testing, such as:

Functional tests.

While the earlier tests are often conducted by developers themselves, functional tests are usually done by QA department to ensure that the product corresponds to the requirements. While unit, integration and system tests are focused on the actual blocks and their interaction, functional tests are focused on requirements, which means that they treat the application as a black box.

For example, if a requirement specifies that the product cannot be purchased more than once per ten seconds by the same user, the test would consist of ordering the product twice in a period of ten seconds and check that the second order failed. Here, the QA tester doesn't care about how the functionality is implemented and what parts of the app are interacting to prevent the frequent purchase.

There is also security testing, A/B testing, regression testing, acceptance testing, non-functional testing, etc., but let's focus on system and functional tests above.

A functional test such as:

Ensure credit card information is remembered by the website.
Go to the product 123.
Add it to cart.
Go to cart.
Make the one-click purchase.
Repeat steps 2 to 5, given that the entire test should take less than ten seconds.
Ensure the last step fails and the user is informed that:
- The purchase was not made because there is a risk of mistake from the user,
- The IP address was saved in case of abuse,
- The e-mail was sent to inform the user about the risk of abuse,
- The credit card was not debited.

is:

Impossible to make by hand (unless you have a really fast tester),
Is just too painful to do by hand anyway (especially in a context of Continuous Integration, where it may need to be done dozens of times per day, among several thousand of other tests),
Is quite difficult to implement using "ordinary" programming, such as a bunch of HTTP requests and responses checking,
Would be unmaintainable if implemented using "ordinary" programming.

This is when Selenium is useful. You create your scenario, and Selenium runs it again and again, checking that the test still passes. A similar scenario concerns system testing; although I don't expect Selenium to be very present here, it's not excluded that some teams rely on Selenium for this sort of testing.

If your project has requirements, a bunch of Selenium tests will be organized around those requirements, like in the example in my answer.

If not, each of those tests will just be a possible scenario which could get terribly wrong, similarly to what you do when choosing what unit tests to create. Just like in unit tests, you will test some method for input value 3 (ordinary case), 0 (edge case), -1 (exceptional case) and NaN (exceptional case), Selenium tests can encompass very diverse situations, such as:

The user purchases a product. That's all.

This is also probably the most crucial test one can have for an e-commerce website: if users can't purchase, it would be slightly problematic.
The user adds a product to the cart, waits until the product is not available any longer, and then tries to purchase it.
The user adds a product, then removes it, then presses Back, and tries to purchase.
The user bruteforces the website by adding every available product with maximum quantities in the shortest possible amount of time, and tries to purchase that.
The user starts purchasing a product, but leaves when the transaction is running, and never returns.

Python – When to Create a Single Class Instance vs Working with the Class

Given a Python class which will be instantiated only once, i.e. there will be only one object of the class. I was wondering in which cases it makes sense to create a single class instance instead of working directly with the class instead.

So it's this:

class Singleton:
    '''don't bother instantiating me'''
    clsvar1 = 'foo'

    @classmethod
    def foobar(cls, *args, **kwargs):
        if condition():
            cls.clsvar1 = 'bar'

versus this?

class Singleton:
    '''instantiate and use me'''
    def __init__(self):
        self.var1 = 'foo'

    def foobar(self, *args, **kwargs):
        if condition():
            self.var1 = 'bar'

Recommendation

I definitely would prefer the one that's intended to be instantiated. When you create a "type of thing" that implies that you create things of that type.

The motivation is to group related code and data and having an interface to it.

That said, why not just use a module since all you want is a namespace? Modules are singletons, group related code and data, and this is a bit simpler and probably would be considered more Pythonic:

var1 ='foo'

def foobar(*args, **kwargs):
    global var1
    if condition():
        var1 = 'bar'

So the usage would be instead of:

from modules.singleton import Singleton
Singleton.foobar()

from modules.singleton import Singleton
the_singleton = Singleton()
the_singleton.foobar()

do this:

from modules import singleton
singleton.foobar()

Best Answer

Related Solutions

Selenium – Best Use Cases for Selenium Testing

Python – When to Create a Single Class Instance vs Working with the Class

Related Topic