asset: spalten tag/monat/3monate... ok + test

asset.py

@@ -10,7 +10,7 @@ from trytond.pyson import Eval, Bool, And, If
 from trytond.report import Report
 from decimal import Decimal
 from datetime import time
-from sql.functions import CurrentDate, CurrentTimestamp
+from sql.functions import CurrentDate, CurrentTimestamp, Round
 from sql.conditionals import Case, Coalesce
 from sql import Literal
 
@@ -78,31 +78,31 @@ class Asset(ModelSQL, ModelView):
         states={
             'readonly': ~Bool(Eval('updtsource')),
         }, depends=['updtsource'])
-    nextupdtate = fields.Function(fields.DateTime(string='Next Update',
+    nextupdate = fields.Function(fields.DateTime(string='Next Update',
         readonly=True),
-        'get_nextupdtates', searcher='search_nextupdtate')
+        'get_nextupdates', searcher='search_nextupdate')
 
     # percentage change
     change_day1 = fields.Function(fields.Numeric(string='Previous Day',
         help='percentage change in value compared to the previous day',
         readonly=True, digits=(16,digits_percent)),
-        'get_percentage_change')
+        'get_percentage_change', searcher='search_percentage')
     change_month1 = fields.Function(fields.Numeric(string='1 Month',
         help='percentage change in value compared to last month',
         readonly=True, digits=(16,digits_percent)),
-        'get_percentage_change')
+        'get_percentage_change', searcher='search_percentage')
     change_month3 = fields.Function(fields.Numeric(string='3 Months',
         help='percentage change in value during 3 months',
         readonly=True, digits=(16,digits_percent)),
-        'get_percentage_change')
+        'get_percentage_change', searcher='search_percentage')
     change_month6 = fields.Function(fields.Numeric(string='6 Months',
         help='percentage change in value during 6 months',
         readonly=True, digits=(16,digits_percent)),
-        'get_percentage_change')
+        'get_percentage_change', searcher='search_percentage')
     change_month12 = fields.Function(fields.Numeric(string='1 Year',
         help='percentage change in value during 1 year',
         readonly=True, digits=(16,digits_percent)),
-        'get_percentage_change')
+        'get_percentage_change', searcher='search_percentage')
 
     @classmethod
     def view_attributes(cls):
@@ -136,137 +136,10 @@ class Asset(ModelSQL, ModelView):
         return 4
 
     @classmethod
-    def get_percentage_sql(cls, table_asset, name_lst):
+    def default_updttime(cls):
-        """ get table for percentages and dates
+        """ 14 o'clock UTC
-            generate adapted query
         """
-        pool = Pool()
+        return time(14, 0)
-        Rate = pool.get('investment.rate')
-        tab_rate_today = Rate.__table__()
-
-        rate_tab = {
-            'day1': {'tab': Rate.__table__(), 'day': 0},
-            'month1': {'tab': Rate.__table__(), 'day': 30},
-            'month3': {'tab': Rate.__table__(), 'day': 3*30},
-            'month6': {'tab': Rate.__table__(), 'day': 6*30},
-            'month12': {'tab': Rate.__table__(), 'day': 12*30},
-            }
-        context = Transaction().context
-
-        # create tables to query percentual changes for
-        # 1 day, 30 days, 3 months, 6 months, 1 year
-        query_date = context.get('qdate', CurrentDate())
-        query_today = table_asset.join(tab_rate_today,
-                condition=table_asset.id==tab_rate_today.asset,
-            ).select(
-                table_asset.id,
-                tab_rate_today.date,
-                tab_rate_today.rate,
-                distinct_on=[table_asset.id],
-                order_by=[table_asset.id, tab_rate_today.date.desc],
-                where=tab_rate_today.date <= query_date,
-            )
-
-        # create join for requested fields, to minimize database-load
-        query = query_today
-        for name in name_lst:
-            query = query.join(rate_tab[name]['tab'],
-                # select newest date from <period> until 3 days older
-                condition=(query_today.id==rate_tab[name]['tab'].asset) & \
-                    (query_today.date > (rate_tab[name]['tab'].date + Literal(rate_tab[name]['day']))) & \
-                    (query_today.date < (rate_tab[name]['tab'].date + Literal(rate_tab[name]['day'] + 3))),
-                type_ = 'LEFT OUTER')
-
-        # add select for requested fields to join
-        select_lst = [
-            query_today.id,
-            query_today.date,
-            ]
-        for name in name_lst:
-            select_lst.append(
-                Case(
-                    ((rate_tab[name]['tab'].rate != None) & (query_today.rate != None) & \
-                        (rate_tab[name]['tab'].rate != Literal(0.0)),
-                        query_today.rate * Literal(100.0) / rate_tab[name]['tab'].rate - Literal(100.0)),
-                    else_ = None,
-                    ).as_(name))
-
-        order_by_lst = [query_today.id]
-        order_by_lst.extend([
-                rate_tab[name]['tab'].date.desc for name in name_lst
-            ])
-
-        query = query.select(
-            *select_lst,
-            distinct_on=[query_today.id],
-            order_by=order_by_lst,
-            )
-
-        # ~ query = query_today.join(tab_rate_1day,
-                # ~ # select newest date from yesterday until 3 days old
-                # ~ condition=(query_today.id==tab_rate_1day.asset) & \
-                    # ~ (query_today.date > tab_rate_1day.date) & \
-                    # ~ (query_today.date < tab_rate_1day.date + Literal(3)),
-                # ~ type_ = 'LEFT OUTER',
-            # ~ ).join(tab_rate_1month,
-                # ~ # select newest date from 1 month ago until +3 days old
-                # ~ condition=(query_today.id==tab_rate_1month.asset) & \
-                    # ~ (query_today.date > tab_rate_1month.date + Literal(30)) & \
-                    # ~ (query_today.date < tab_rate_1month.date + Literal(33)),
-                # ~ type_ = 'LEFT OUTER',
-            # ~ ).select(
-                # ~ query_today.id,
-                # ~ query_today.date,
-                # ~ Case(
-                    # ~ ((tab_rate_1day.rate != None) & (query_today.rate != None) & \
-                        # ~ (tab_rate_1day.rate != Literal(0.0)),
-                        # ~ query_today.rate * Literal(100.0) / tab_rate_1day.rate - Literal(100.0)),
-                    # ~ else_ = None,
-                    # ~ ).as_('day1'),
-                # ~ Case(
-                    # ~ ((tab_rate_1month.rate != None) & (query_today.rate != None) & \
-                        # ~ (tab_rate_1month.rate != Literal(0.0)),
-                        # ~ query_today.rate * Literal(100.0) / tab_rate_1month.rate - Literal(100.0)),
-                    # ~ else_ = None,
-                    # ~ ).as_('month1'),
-                # ~ distinct_on=[query_today.id],
-                # ~ order_by=[
-                        # ~ query_today.id,
-                        # ~ tab_rate_1day.date.desc,
-                        # ~ tab_rate_1month.date.desc,
-                    # ~ ],
-            # ~ )
-
-        return query
-
-    @classmethod
-    def get_percentage_change(cls, assets, names):
-        """ get percentage per period
-        """
-        pool = Pool()
-        Asset = pool.get('investment.asset')
-        tab_asset = Asset.__table__()
-        cursor = Transaction().connection.cursor()
-
-        name_lst = [x[len('change_'):] for x in names]
-        tab_percent = cls.get_percentage_sql(tab_asset, name_lst)
-        query = tab_percent.select(
-                tab_percent.id,
-                *[getattr(tab_percent, x) for x in name_lst],
-                where=tab_percent.id.in_([x.id for x in assets]),
-            )
-        cursor.execute(*query)
-        records = cursor.fetchall()
-
-        result = {x:{y.id: None for y in assets} for x in names}
-        exp = Decimal(Decimal(1) / 10 ** digits_percent)
-        for record in records:
-            cnt1 = 1
-            for x in name_lst:
-                result['change_%s' % x][record[0]] = record[cnt1].quantize(exp) \
-                    if record[cnt1] is not None else None
-                cnt1 += 1
-        return result
 
     @classmethod
     def get_rate_data(cls, assets, names):
@@ -365,6 +238,185 @@ class Asset(ModelSQL, ModelView):
                 if self.company.currency.id != self.currency.id:
                     return self.company.currency.id
 
+    @classmethod
+    def get_percentage_sql(cls, name_lst):
+        """ get table for percentages and dates,
+            generate adapted query
+        """
+        pool = Pool()
+        Rate = pool.get('investment.rate')
+        Asset = pool.get('investment.asset')
+        tab_asset = Asset.__table__()
+        tab_rate_today = Rate.__table__()
+
+        rate_tab = {
+            'day1': {'tab': Rate.__table__(), 'day': 0},
+            'month1': {'tab': Rate.__table__(), 'day': 30},
+            'month3': {'tab': Rate.__table__(), 'day': 3*30},
+            'month6': {'tab': Rate.__table__(), 'day': 6*30},
+            'month12': {'tab': Rate.__table__(), 'day': 12*30},
+            }
+        context = Transaction().context
+
+        # create tables to query percentual changes for
+        # 1 day, 30 days, 3 months, 6 months, 1 year
+        query_date = context.get('qdate', CurrentDate())
+        query_today = tab_asset.join(tab_rate_today,
+                condition=tab_asset.id==tab_rate_today.asset,
+            ).select(
+                tab_asset.id,
+                tab_rate_today.date,
+                tab_rate_today.rate,
+                distinct_on=[tab_asset.id],
+                order_by=[tab_asset.id, tab_rate_today.date.desc],
+                where=tab_rate_today.date <= query_date,
+            )
+
+        # create join for requested fields, to minimize database-load
+        query = query_today
+        for name in name_lst:
+            query = query.join(rate_tab[name]['tab'],
+                # select newest date from <period> until 5 days older
+                condition=(query_today.id==rate_tab[name]['tab'].asset) & \
+                    (query_today.date > (rate_tab[name]['tab'].date + Literal(rate_tab[name]['day']))) & \
+                    (query_today.date <= (rate_tab[name]['tab'].date + Literal(rate_tab[name]['day'] + 5))),
+                type_ = 'LEFT OUTER')
+
+        # add select for requested fields to join
+        select_lst = [
+            query_today.id,
+            query_today.date,
+            ]
+        for name in name_lst:
+            select_lst.append(
+                Case(
+                    ((rate_tab[name]['tab'].rate != None) & (query_today.rate != None) & \
+                        (rate_tab[name]['tab'].rate != Literal(0.0)),
+                        query_today.rate * Literal(100.0) / rate_tab[name]['tab'].rate - Literal(100.0)),
+                    else_ = None,
+                ).as_(name))
+
+        order_by_lst = [query_today.id]
+        order_by_lst.extend([
+                rate_tab[name]['tab'].date.desc for name in name_lst
+            ])
+
+        query = query.select(
+            *select_lst,
+            distinct_on=[query_today.id],
+            order_by=order_by_lst,
+            )
+        return query
+
+    @staticmethod
+    def order_change_day1(tables):
+        """ order day1
+        """
+        Assert = Pool().get('investment.asset')
+        tab_asset = Asset.get_percentage_sql(['day1'])
+        table, _ = tables[None]
+
+        query = tab_asset.select(
+                getattr(tab_asset, 'day1'),
+                where=tab_asset.id==table.id,
+            )
+        return [query]
+
+    @staticmethod
+    def order_change_month1(tables):
+        """ order month1
+        """
+        Assert = Pool().get('investment.asset')
+        tab_asset = Asset.get_percentage_sql(['month1'])
+        table, _ = tables[None]
+
+        query = tab_asset.select(
+                getattr(tab_asset, 'month1'),
+                where=tab_asset.id==table.id,
+            )
+        return [query]
+
+    @staticmethod
+    def order_change_month3(tables):
+        """ order month1
+        """
+        Assert = Pool().get('investment.asset')
+        tab_asset = Asset.get_percentage_sql(['month3'])
+        table, _ = tables[None]
+
+        query = tab_asset.select(
+                getattr(tab_asset, 'month3'),
+                where=tab_asset.id==table.id,
+            )
+        return [query]
+
+    @staticmethod
+    def order_change_month6(tables):
+        """ order month1
+        """
+        Assert = Pool().get('investment.asset')
+        tab_asset = Asset.get_percentage_sql(['month6'])
+        table, _ = tables[None]
+
+        query = tab_asset.select(
+                getattr(tab_asset, 'month6'),
+                where=tab_asset.id==table.id,
+            )
+        return [query]
+
+    @staticmethod
+    def order_change_month12(tables):
+        """ order month1
+        """
+        Assert = Pool().get('investment.asset')
+        tab_asset = Asset.get_percentage_sql(['month12'])
+        table, _ = tables[None]
+
+        query = tab_asset.select(
+                getattr(tab_asset, 'month12'),
+                where=tab_asset.id==table.id,
+            )
+        return [query]
+
+    @classmethod
+    def search_percentage(cls, names, clause):
+        """ search for percentages
+        """
+        Operator = fields.SQL_OPERATORS[clause[1]]
+        field_name = clause[0][len('change_'):]
+        tab_percent = cls.get_percentage_sql([field_name])
+
+        query = tab_percent.select(tab_percent.id,
+                where=Operator(Round(getattr(tab_percent, field_name), 2),
+                                clause[2]))
+        return [('id', 'in', query)]
+
+    @classmethod
+    def get_percentage_change(cls, assets, names):
+        """ get percentage per period
+        """
+        cursor = Transaction().connection.cursor()
+
+        name_lst = [x[len('change_'):] for x in names]
+        tab_percent = cls.get_percentage_sql(name_lst)
+        query = tab_percent.select(
+                tab_percent.id,
+                *[getattr(tab_percent, x) for x in name_lst],
+                where=tab_percent.id.in_([x.id for x in assets]),
+            )
+        cursor.execute(*query)
+        records = cursor.fetchall()
+
+        result = {x:{y.id: None for y in assets} for x in names}
+        exp = Decimal(Decimal(1) / 10 ** digits_percent)
+        for record in records:
+            cnt1 = 1
+            for x in name_lst:
+                result['change_%s' % x][record[0]] = record[cnt1].quantize(exp) \
+                    if record[cnt1] is not None else None
+                cnt1 += 1
+        return result
+
     @classmethod
     def get_next_update_datetime_sql(cls):
         """ get sql for datetime of next planned update
@@ -391,7 +443,7 @@ class Asset(ModelSQL, ModelView):
         return query
 
     @classmethod
-    def get_nextupdtates(cls, assets, names):
+    def get_nextupdates(cls, assets, names):
         """ get timestamp of next update
         """
         Asset2 = Pool().get('investment.asset')
@@ -410,21 +462,19 @@ class Asset(ModelSQL, ModelView):
 
         for record in records:
             (id1, updt) = record
-            r1 = {'nextupdtate': updt}
+            r1 = {'nextupdate': updt}
 
             for n in names:
                 result[n][id1] = r1[n]
         return result
 
     @classmethod
-    def search_nextupdtate(cls, names, clause):
+    def search_nextupdate(cls, names, clause):
         """ search for assets to update
         """
         Asset2 = Pool().get('investment.asset')
         tab_updt = Asset2.get_next_update_datetime_sql()
-
         Operator = fields.SQL_OPERATORS[clause[1]]
-        context = Transaction().context
 
         query = tab_updt.select(
                 tab_updt.id,
@@ -539,10 +589,11 @@ class Asset(ModelSQL, ModelView):
         pool = Pool()
         Asset2 = pool.get('investment.asset')
         OnlineSource = pool.get('investment.source')
+        context = Transaction().context
 
         query_time = context.get('qdatetime', CurrentTimestamp())
         for asset in Asset2.search([
-                ('updttime', '<=', query_time),
+                ('nextupdate', '<=', query_time),
             ]):
             OnlineSource.update_rate(asset)
 

locale/de.po

@@ -194,7 +194,7 @@ msgctxt "field:investment.asset,updttime:"
 msgid "Time"
 msgstr "Zeitpunkt"
 
-msgctxt "field:investment.asset,nextupdtate:"
+msgctxt "field:investment.asset,nextupdate:"
 msgid "Next Update"
 msgstr "nächste Aktualisierung"
 

locale/en.po

@@ -166,7 +166,7 @@ msgctxt "field:investment.asset,updttime:"
 msgid "Time"
 msgstr "Time"
 
-msgctxt "field:investment.asset,nextupdtate:"
+msgctxt "field:investment.asset,nextupdate:"
 msgid "Next Update"
 msgstr "Next Update"
 

tests/test_asset.py

@@ -112,8 +112,9 @@ class AssetTestCase(ModuleTestCase):
         self.assertEqual(asset.rec_name, 'Product 1 - 2.4500 usd/Unit [05/15/2022]')
 
     @with_transaction()
-    def test_asset_percentges(self):
+    def test_asset_percentages_daterange(self):
-        """ create asset, add rates, check percentages
+        """ create asset, add rates, check selection of
+            value
         """
         Asset = Pool().get('investment.asset')
 
@@ -156,8 +157,148 @@ class AssetTestCase(ModuleTestCase):
             ])
         self.assertEqual(asset1.rec_name, 'Product 1 - 2.6000 usd/Unit [05/16/2022]')
         self.assertEqual(asset2.rec_name, 'Product 1 - 5.2500 usd/Unit [05/15/2022]')
-        self.assertEqual(asset1.change_day1, Decimal('6.1'))
+        self.assertEqual(asset1.change_day1, Decimal('6.12'))
         self.assertEqual(asset2.change_day1, Decimal('-8.7'))
+        self.assertEqual(asset1.change_month1, None)
+        self.assertEqual(asset2.change_month1, None)
+        self.assertEqual(asset1.change_month3, None)
+        self.assertEqual(asset2.change_month3, None)
+        self.assertEqual(asset1.change_month6, None)
+        self.assertEqual(asset2.change_month6, None)
+        self.assertEqual(asset1.change_month12, None)
+        self.assertEqual(asset2.change_month12, None)
+
+        # check ordering
+        assets = Asset.search([
+                ('change_day1', '!=', Decimal('0.0')),
+            ], order=[('change_day1', 'ASC')])
+        self.assertEqual(len(assets), 2)
+        self.assertEqual(assets[0].change_day1, Decimal('-8.7'))
+        self.assertEqual(assets[1].change_day1, Decimal('6.12'))
+
+        assets = Asset.search([
+                ('change_day1', '!=', Decimal('0.0')),
+            ], order=[('change_day1', 'DESC')])
+        self.assertEqual(len(assets), 2)
+        self.assertEqual(assets[0].change_day1, Decimal('6.12'))
+        self.assertEqual(assets[1].change_day1, Decimal('-8.7'))
+
+        # check 5-day-range
+        # four days
+        Asset.write(*[
+            [asset1],
+            {
+                'rates': [('write', [asset1.rates[1]], {
+                    'date': date(2022, 5, 12),
+                    })],
+            }])
+        self.assertEqual(asset1.rates[0].date, date(2022, 5, 16))
+        self.assertEqual(asset1.rates[1].date, date(2022, 5, 12))
+        self.assertEqual(asset1.change_day1, Decimal('6.12'))
+        # five days
+        Asset.write(*[
+            [asset1],
+            {
+                'rates': [('write', [asset1.rates[1]], {
+                    'date': date(2022, 5, 11),
+                    })],
+            }])
+        self.assertEqual(asset1.rates[0].date, date(2022, 5, 16))
+        self.assertEqual(asset1.rates[1].date, date(2022, 5, 11))
+        self.assertEqual(asset1.change_day1, Decimal('6.12'))
+        # six days
+        Asset.write(*[
+            [asset1],
+            {
+                'rates': [('write', [asset1.rates[1]], {
+                    'date': date(2022, 5, 10),
+                    })],
+            }])
+        self.assertEqual(asset1.rates[0].date, date(2022, 5, 16))
+        self.assertEqual(asset1.rates[1].date, date(2022, 5, 10))
+        self.assertEqual(asset1.change_day1, None)
+
+    @with_transaction()
+    def test_asset_percentges_values(self):
+        """ create asset, add rates, check percentages
+        """
+        Asset = Pool().get('investment.asset')
+
+        company = self.prep_asset_company()
+        product = self.prep_asset_product(
+            name='Product 1',
+            description='some asset')
+
+        asset1 = self.prep_asset_item(
+            company=company,
+            product = product)
+
+        self.assertEqual(asset1.rec_name, 'Product 1 - - usd/Unit [-]')
+
+        Asset.write(*[
+            [asset1],
+            {
+                'rates': [('create', [{
+                    'date': date(2022, 5, 15),
+                    'rate': Decimal('2.45'),
+                    }, {
+                    'date': date(2022, 5, 16),
+                    'rate': Decimal('2.6'),
+                    }, {
+                    'date': date(2022, 4, 14),
+                    'rate': Decimal('2.2'),
+                    }, {
+                    'date': date(2022, 2, 14),
+                    'rate': Decimal('2.8'),
+                    },])],
+            }])
+        self.assertEqual(asset1.rec_name, 'Product 1 - 2.6000 usd/Unit [05/16/2022]')
+        self.assertEqual(len(asset1.rates), 4)
+        self.assertEqual(asset1.rates[0].date, date(2022, 5, 16))
+        self.assertEqual(asset1.rates[1].date, date(2022, 5, 15))
+        self.assertEqual(asset1.rates[2].date, date(2022, 4, 14))
+        self.assertEqual(asset1.rates[3].date, date(2022, 2, 14))
+
+        self.assertEqual(asset1.change_day1, Decimal('6.12'))
+        self.assertEqual(asset1.change_month1, Decimal('18.18'))
+        self.assertEqual(asset1.change_month3, Decimal('-7.14'))
+        self.assertEqual(asset1.change_month6, None)
+        self.assertEqual(asset1.change_month12, None)
+
+        # call order-functions
+        Asset.search([], order=[('change_day1', 'ASC')])
+        Asset.search([], order=[('change_month1', 'ASC')])
+        Asset.search([], order=[('change_month3', 'ASC')])
+        Asset.search([], order=[('change_month6', 'ASC')])
+        Asset.search([], order=[('change_month12', 'ASC')])
+
+        # searcher
+        self.assertEqual(
+            Asset.search_count([('change_day1', '>', Decimal('6.1'))]),
+            1)
+        self.assertEqual(
+            Asset.search_count([('change_day1', '>', Decimal('6.15'))]),
+            0)
+        self.assertEqual(
+            Asset.search_count([('change_day1', '=', Decimal('6.12'))]),
+            1)
+
+        self.assertEqual(
+            Asset.search_count([('change_month1', '>', Decimal('18.0'))]),
+            1)
+        self.assertEqual(
+            Asset.search_count([('change_month1', '>', Decimal('18.18'))]),
+            0)
+        self.assertEqual(
+            Asset.search_count([('change_month1', '=', Decimal('18.18'))]),
+            1)
+
+        self.assertEqual(
+            Asset.search_count([('change_month3', '=', Decimal('-7.14'))]),
+            1)
+        self.assertEqual(
+            Asset.search_count([('change_month6', '=', None)]),
+            1)
 
     @with_transaction()
     def test_asset_check_onlinesource_onoff(self):
@@ -181,7 +322,7 @@ class AssetTestCase(ModuleTestCase):
             }])
 
         self.assertEqual(asset.updtsource, None)
-        self.assertEqual(asset.updttime, None)
+        self.assertEqual(asset.updttime, time(14,0))
 
         asset.updtsource = o_source
         asset.updttime = time(10, 45)
@@ -231,13 +372,13 @@ class AssetTestCase(ModuleTestCase):
             self.assertEqual(asset2.updtsource.rec_name, 'Source 1')
             self.assertEqual(asset2.updttime, time(10, 45))
             self.assertEqual(len(asset2.rates), 0)
-            self.assertEqual(asset2.nextupdtate, datetime(2022, 10, 15, 10, 45))
+            self.assertEqual(asset2.nextupdate, datetime(2022, 10, 15, 10, 45))
 
             self.assertEqual(
-                Asset.search_count([('nextupdtate', '<', datetime(2022, 10, 15, 10, 45))]),
+                Asset.search_count([('nextupdate', '<', datetime(2022, 10, 15, 10, 45))]),
                 0)
             self.assertEqual(
-                Asset.search_count([('nextupdtate', '>=', datetime(2022, 10, 15, 10, 45))]),
+                Asset.search_count([('nextupdate', '>=', datetime(2022, 10, 15, 10, 45))]),
                 1)
 
         # add rate at yesterday
@@ -256,13 +397,13 @@ class AssetTestCase(ModuleTestCase):
         self.assertEqual(asset.updttime, time(10, 45))
         self.assertEqual(len(asset.rates), 1)
         self.assertEqual(asset.rates[0].date, date(2022, 10, 14))
-        self.assertEqual(asset.nextupdtate, datetime(2022, 10, 15, 10, 45))
+        self.assertEqual(asset.nextupdate, datetime(2022, 10, 15, 10, 45))
 
         self.assertEqual(
-            Asset.search_count([('nextupdtate', '<', datetime(2022, 10, 15, 10, 45))]),
+            Asset.search_count([('nextupdate', '<', datetime(2022, 10, 15, 10, 45))]),
             0)
         self.assertEqual(
-            Asset.search_count([('nextupdtate', '>=', datetime(2022, 10, 15, 10, 45))]),
+            Asset.search_count([('nextupdate', '>=', datetime(2022, 10, 15, 10, 45))]),
             1)
 
         # add rate at today
@@ -281,13 +422,13 @@ class AssetTestCase(ModuleTestCase):
         self.assertEqual(asset2.updttime, time(10, 45))
         self.assertEqual(len(asset2.rates), 2)
         self.assertEqual(asset2.rates[0].date, date(2022, 10, 15))
-        self.assertEqual(asset2.nextupdtate, datetime(2022, 10, 16, 10, 45))
+        self.assertEqual(asset2.nextupdate, datetime(2022, 10, 16, 10, 45))
 
         self.assertEqual(
-            Asset.search_count([('nextupdtate', '<', datetime(2022, 10, 15, 10, 45))]),
+            Asset.search_count([('nextupdate', '<', datetime(2022, 10, 15, 10, 45))]),
             0)
         self.assertEqual(
-            Asset.search_count([('nextupdtate', '>=', datetime(2022, 10, 15, 10, 45))]),
+            Asset.search_count([('nextupdate', '>=', datetime(2022, 10, 15, 10, 45))]),
             1)
 
     @with_transaction()

tests/test_source.py

@@ -8,7 +8,7 @@ from trytond.pool import Pool
 from trytond.modules.company.tests import create_company
 from trytond.transaction import Transaction
 from decimal import Decimal
-from datetime import time, date
+from datetime import time, date, datetime
 from unittest.mock import MagicMock
 from requests import Response
 import requests
@@ -66,26 +66,34 @@ class SourceTestCase(ModuleTestCase):
             {
                 'updtsource': osource.id,
             }])
-        self.assertEqual(asset.wkn, '965515')
-        self.assertEqual(asset.isin, 'XC0009655157')
-        self.assertEqual(asset.secsymb, '1472977')
-        self.assertEqual(asset.updtsource.rec_name, 'Source 1')
-        self.assertEqual(len(asset.rates), 0)
 
-        # fake server-response
+        with Transaction().set_context({
-        resp1 = Response()
+            'qdate': date(2022, 10, 1),
-        resp1._content = """<html><body>Response from finance-server
+            'qdatetime': datetime(2022, 10, 2, 10, 0, 0),
+            }):
+            asset2, = Asset.browse([asset])
+            self.assertEqual(asset2.wkn, '965515')
+            self.assertEqual(asset2.isin, 'XC0009655157')
+            self.assertEqual(asset2.secsymb, '1472977')
+            self.assertEqual(asset2.updttime, time(14, 0))
+            self.assertEqual(asset2.updtsource.rec_name, 'Source 1')
+            self.assertEqual(asset2.nextupdate, datetime(2022, 10, 2, 14, 0))
+            self.assertEqual(len(asset.rates), 0)
+
+            # fake server-response
+            resp1 = Response()
+            resp1._content = """<html><body>Response from finance-server
 Course Date 14.08.2022 Today
 High 34,87 EUR
 </body></html>""".encode('utf8')
-        resp1.status_code = 200
+            resp1.status_code = 200
-        resp1.reason = 'OK'
+            resp1.reason = 'OK'
-        requests.get = MagicMock(return_value=resp1)
+            requests.get = MagicMock(return_value=resp1)
 
-        OSource.update_rate(asset)
+            OSource.update_rate(asset)
-        self.assertEqual(len(asset.rates), 1)
+            self.assertEqual(len(asset.rates), 1)
-        self.assertEqual(asset.rates[0].date, date(2022, 8, 14))
+            self.assertEqual(asset.rates[0].date, date(2022, 8, 14))
-        self.assertEqual(asset.rates[0].rate, Decimal('34.87'))
+            self.assertEqual(asset.rates[0].rate, Decimal('34.87'))
 
     @with_transaction()
     def test_waitlist_source_check_regex(self):

view/asset_form.xml

@@ -9,8 +9,8 @@ full copyright notices and license terms. -->
     <field name="rate" symbol="currency"/>
 
     <label id="labdate" string=" "/>
-    <label name="nextupdtate" colspan="2"/>
+    <label name="nextupdate" colspan="2"/>
-    <field name="nextupdtate"/>
+    <field name="nextupdate"/>
     <label name="date" />
     <field name="date"/>