Python脚本被杀死

Question

Environment Flask 0.10.1 SqlAlchemy 1.0.10 Python 3.4.3

Using unittest

I have created two separate tests whose goals are looking into the databases through 700k records and doing some string finds. When the tests are executed one at a time, it works fine, but when the whole script is executed with:

python name_of_script.py

it exits with "KILLED" at random places.

The main code on both tests go something like this:

def test_redundant_categories_exist(self):
    self.assertTrue(self.get_redundant_categories() > 0, 'There are 0 redundant categories to remove. Cannot test removing them if there are none to remove.')

def get_redundant_categories(self):
        total = 0
        with get_db_session_scope(db.session) as db_session:
            records = db_session.query(Category)
            for row in records:
                if len(row.c) > 1:
                    c = row.c
                    #TODO: threads, each thread handles a bulk of rows
                    redundant_categories = [cat_x.id
                                            for cat_x in c
                                            for cat_y in c
                                            if cat_x != cat_y and re.search(r'(^|/)' + cat_x.path + r'($|/)', cat_y.path)
                                            ]
                    total += len(redundant_categories)
            records = None
            db_session.close()
        return total

The other test calls a function located in the manager.py file that does something similar, but with an added bulk delete in the database.

    def test_remove_redundant_mappings(self):
        import os
        os.system( "python ../../manager.py remove_redundant_mappings" )
        self.assertEqual(self.get_redundant_categories(), 0, "There are redundant categories left after running manager.py remove_redundant_mappings()")

Is it possible for the data to be kept in memory between tests? I don't quite understand how executing the tests individually works, but when run back to back, the process ends with Killed.

Any ideas?

Edit (things I've tried to no avail):

• import the function from manager.py and call it without os.system(..)
• import gc and run a gc.collect() after get_redundant_categories() and after calling remove_redundant_mappings()

Answer 1

While searching high and low, I serendipitously came upon the following comment in this StackOverflow question/answer

What is happening, I think, is that people are instantiating sessions and not closing them. The objects are then being garbage collected without closing the sessions. Why sqlalchemy sessions don't close themselves when the session object goes out of scope has always and will always be beyond me. @melchoir55

So I added the following the to the method that was being tested:

db_session.close()

Now the unittest executes without getting killed.