Python SQLAlemchy mock testing --- data stubbing

Question

I am trying to use the mock-alchemy for data stubbing mock unittesting. I am following this example

To run the code, I have some modification like this:

demo_test.py

import datetime
import unittest
from unittest import mock

import pytest
from mock_alchemy.mocking import UnifiedAlchemyMagicMock

from mock_demo.data_analysis import complex_data_analysis, Data1, Data2, Data3, CombinedAnalysis

class TestMockDemo(unittest.TestCase):
    def test_data_analysis(self):
        stop_time = datetime.datetime.utcnow()
        cfg = {
            "final_time": stop_time
        }
        data1_values = [
            Data1(1, 10, 11, 12),
            Data1(2, 20, 21, 22),
            Data1(3, 30, 31, 32),
        ]
        data2_values = [
            Data2(1, 10, 11, 12),
            Data2(2, 20, 21, 22),
            Data2(3, 30, 31, 32),
        ]
        data3_values = [
            Data3(1, 10, 11, 12),
            Data3(2, 20, 21, 22),
            Data3(3, 30, 31, 32),
        ]
        session = UnifiedAlchemyMagicMock(data=[
            (
                [mock.call.query(Data1),
                 mock.call.filter(Data1.data_val1 < 20)],
                data1_values
            ),
            (
                [mock.call.query(Data2),
                 mock.call.filter(Data2.data_val2 < 30)],
                data2_values
            ),
            (
                [mock.call.query(Data3),
                 mock.call.filter(Data3.data_val3 < 40)],
                data3_values
            ),
        ])
        complex_data_analysis(cfg, session)
        expected_anyalsis = [
            CombinedAnalysis(1, 10, 11, 12),
            CombinedAnalysis(2, 20, 21, 22),
            CombinedAnalysis(3, 30, 31, 32),
        ]
        combined_anyalsis = session.query(CombinedAnalysis).all()
        print(combined_anyalsis)
        print(expected_anyalsis)
        assert sorted(combined_anyalsis, key=lambda x: x.pk1) == sorted(expected_anyalsis, key=lambda x: x.pk1)

if __name__ == "__main__":
    unittest.main()

data_analysis.py

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()

# assume similar classes for Data2 and Data3
class Data1(Base):
    __tablename__ = 'some_table'
    pk1 = Column(Integer, primary_key=True)
    data_val1 = Column(Integer)
    data_val2 = Column(Integer)
    data_val3 = Column(Integer)
    def __init__(self, pk1, val1, val2, val3):
        self.pk1 = pk1
        self.data_val1 = val1
        self.data_val2 = val2
        self.data_val3 = val3

class Data2(Base):
    __tablename__ = 'some_table_003'
    pk1 = Column(Integer, primary_key=True)
    data_val1 = Column(Integer)
    data_val2 = Column(Integer)
    data_val3 = Column(Integer)
    def __init__(self, pk1, val1, val2, val3):
        self.pk1 = pk1
        self.data_val1 = val1
        self.data_val2 = val2
        self.data_val3 = val3

class Data3(Base):
    __tablename__ = 'some_table_004'
    pk1 = Column(Integer, primary_key=True)
    data_val1 = Column(Integer)
    data_val2 = Column(Integer)
    data_val3 = Column(Integer)
    def __init__(self, pk1, val1, val2, val3):
        self.pk1 = pk1
        self.data_val1 = val1
        self.data_val2 = val2
        self.data_val3 = val3

class CombinedAnalysis(Base):
    __tablename__ = 'some_table_002'
    pk1 = Column(Integer, primary_key=True)
    analysis_val1 = Column(Integer)
    analysis_val2 = Column(Integer)
    analysis_val3 = Column(Integer)
    def __init__(self, pk1, val1, val2, val3):
        self.pk1 = pk1
        self.analysis_val1 = val1
        self.analysis_val2 = val2
        self.analysis_val3 = val3

    def __eq__(self, other):
        if not isinstance(other, CombinedAnalysis):
            return NotImplemented
        return (
            self.analysis_val1 == other.analysis_val1
            and self.analysis_val2 == other.analysis_val2
            and self.analysis_val3 == other.analysis_val3
        )

def analysis(dataset_first, dataset_second):
    return dataset_first

def intergrate_analysis(d_1, d_2, d_3):
    return d_1

def complex_data_analysis(cfg, session):
    # collects some data upto some point
    dataset1 = session.query(Data1).filter(Data1.data_val1 < 20)
    dataset2 = session.query(Data2).filter(Data2.data_val2 < 30)
    dataset3 = session.query(Data3).filter(Data3.data_val3 < 40)
    # performs some analysis
    analysis12 = analysis(dataset1, dataset2)
    analysis13 = analysis(dataset1, dataset3)
    analysis23 = analysis(dataset2, dataset3)
    # combine the data analysis (returns object CombinedAnalysis)
    combined_analysis = intergrate_analysis(analysis12, analysis13, analysis23)
    # assume the combined_analysis are stored in some SQL table
    session.add_all(combined_analysis)
    session.commit()

I then run the test case and trying to print out the result of the query with this command:

combined_anyalsis = session.query(CombinedAnalysis).all()
print(combined_anyalsis)

and here is the output:

[]

That is an empty list. I would like to ask if anyone knows how can I insert data into the session and perform the test case?

Thanks