Merge pull request 'Development' (#11) from development into master

Reviewed-on: #11

config.example.json

@@ -14,7 +14,9 @@
         "run_session": true,
         "run_token": false,
         "session": {
+            "time_mode": "offset",
             "start_offset_minutes": 5,
+            "start_time": "14:30",
             "end_time": "20:30"
         }
     },
@@ -55,7 +57,9 @@
             "run_token": true,
             "me_instance": "52",
             "session": {
+                "time_mode": "offset",
                 "start_offset_minutes": 7,
+                "start_time": "14:30",
                 "end_time": "20:30"
             },
             "token": {
@@ -68,7 +72,9 @@
                 "delivery_offset_days": 0,
                 "delivery_from_time": "00:00",
                 "delivery_to_time": "23:59",
+                "time_mode": "offset",
                 "session_start_offset_minutes": 5,
+                "session_start_time": "14:30",
                 "session_end_time": "20:00"
             }
         },
@@ -140,7 +146,9 @@
                 "delivery_offset_days": 1,
                 "expiry_time": "20:30",
                 "upc_times": {
+                    "time_mode": "manual",
                     "order_normal_start_time": "13:00",
+                    "order_normal_start_offset_minutes": 10,
                     "order_normal_end_time": "17:00",
                     "trade_session_start_time": "17:00",
                     "trade_session_end_time": "22:00"
@@ -171,13 +179,17 @@
             "token": {
                 "market_code": "NATIONAL",
                 "product_type": "REC",
-        "product_codes": ["REC"],
+                "product_codes": [
+                    "REC"
+                ],
                 "delivery_offset_days": 1,
                 "expiry_time": "20:30",
                 "type_prefix": "REC",
                 "time_sessions": {
                     "ORDER_NOR": {
+                        "time_mode": "offset",
                         "start_offset_minutes": 10,
+                        "start_time": "14:30",
                         "end_time": "19:30"
                     },
                     "ORDER_EXCH": {
@@ -190,6 +202,48 @@
                     }
                 }
             }
+        },
+        "INTRADAY": {
+            "enabled": true,
+            "run_session": true,
+            "run_token": true,
+            "me_instance": "53",
+            "session": {},
+            "token": {
+                "market_code": "NATIONAL",
+                "product_type": "INTRADAY",
+                "product_codes": [
+                    "I_DayStatic_C"
+                ],
+                "generation_mode": "Intraday24by7",
+                "delivery_start_offset_minutes": 5,
+                "trading_start_time": "00:20",
+                "trading_start_days_before_delivery": 1,
+                "duration_before_delivery_end_time": 150,
+                "delivery_to_time": "23:59"
+            }
+        },
+        "DAC": {
+            "enabled": false,
+            "run_session": true,
+            "run_token": true,
+            "me_instance": "57",
+            "session": {
+                "time_mode": "offset",
+                "start_offset_minutes": 5,
+                "end_time": "23:00"
+            },
+            "token": {
+                "market_code": "NATIONAL",
+                "product_type": "DAC",
+                "product_codes": ["DACStatic"],
+                "generation_mode": "DAC",
+                "delivery_start_offset_minutes": 5,
+                "delivery_to_time": "23:59",
+                "session_start_time": "13:00",
+                "session_end_time": "23:00",
+                "delivery_time_period": 15
+            }
         }
     }
 }

tests/locators.py

@@ -39,6 +39,16 @@ class Locator(object):
     tokendeliveryenddate = "//input[@placeholder='DELIVERY_END_DATE']"
     tokenexpirydate = "//input[@placeholder='Token Expiry Date']"
     tokentype = "//input[@name='TYPE' or @placeholder='TYPE']"
+    intradaydeliveryfromdate = "//input[@placeholder='Delivery From Date']"
+    intradaydeliverytodate = "//input[@placeholder='Delivery To Date']"
+    intradaytradingstarttime = "//input[@placeholder='Trading Start Time']"
+    intradaydaysbeforedelivery = "//input[@placeholder='Trading Start days before delivery']"
+    intradaydurationbeforeend = "//input[@placeholder='Duration before delivery end time']"
+    intradaysuccessmessage = "//*[contains(normalize-space(text()), 'Tokens generated successfully')]"
+    dactradingfromdate = "//input[@placeholder='Trading From Date']"
+    dactradingtodate = "//input[@placeholder='Trading To Date']"
+    dacsessionstarttime = "//input[@placeholder='Session Start Time']"
+    dacsessionendtime = "//input[@placeholder='Session End Time']"
     tokentradedate = "//input[@placeholder='Trade Date']"
     upcordernormalstart = "//input[@name='ses3StartTime']"
     upcordernormalend = "//input[@name='ses3EndTime']"

tests/setup/sessions/test_session.py

@@ -13,13 +13,21 @@ from tests.locators import Locator
 def get_session_window(config):
 
     session_config = config.get("setup", {}).get("session", {})
+    time_mode = session_config.get("time_mode", "offset").lower()
+    if time_mode == "manual":
+        start_time = session_config.get("start_time")
+        if not start_time:
+            raise ValueError("Session time_mode 'manual' requires start_time")
+    elif time_mode == "offset":
         start_offset_minutes = session_config.get("start_offset_minutes", 7)
+        start_time = (datetime.now() + timedelta(minutes=start_offset_minutes)).strftime("%H:%M")
+    else:
+        raise ValueError("Session time_mode must be 'manual' or 'offset'")
     end_time = session_config.get("end_time", "20:30")
 
-    start_datetime = datetime.now() + timedelta(minutes=start_offset_minutes)
     today = datetime.now().strftime("%d/%m/%Y")
 
-    return start_datetime.strftime("%d/%m/%Y %H:%M"), f"{today} {end_time}"
+    return f"{today} {start_time}", f"{today} {end_time}"
 
 
 def create_session(driver, step, config):

tests/setup/tokens/test_trading_token.py

@@ -56,15 +56,28 @@ def get_delivery_date_and_expiry(token):
     return delivery_date, token_expiry
 
 
+def get_intraday_delivery_window(token, now=None):
+    """Return an Intraday delivery window that cannot start in the past."""
+    now = datetime.now() if now is None else now
+    start = now + timedelta(minutes=token.get("delivery_start_offset_minutes", 5))
+    start_text = start.strftime("%d/%m/%Y %H:%M")
+    end_text = f"{start.strftime('%d/%m/%Y')} {token.get('delivery_to_time', '23:59')}"
+    return start_text, end_text
+
+
 def get_time_session_times(token, row_text, default_start_time, default_end_time):
 
     time_session_config = token.get("time_sessions", {}).get(row_text, {})
+    time_mode = time_session_config.get("time_mode")
     start_time = time_session_config.get("start_time")
 
-    if start_time is None:
+    if time_mode == "offset":
         start_offset_minutes = time_session_config.get("start_offset_minutes")
-        if start_offset_minutes is not None:
+        if start_offset_minutes is None:
+            raise ValueError(f"{row_text} offset mode requires start_offset_minutes")
         start_time = (datetime.now() + timedelta(minutes=start_offset_minutes)).strftime("%H:%M")
+    elif time_mode == "manual" and not start_time:
+        raise ValueError(f"{row_text} manual mode requires start_time")
 
     return (
         start_time or default_start_time,
@@ -72,6 +85,29 @@ def get_time_session_times(token, row_text, default_start_time, default_end_time
     )
 
 
+def get_upc_order_normal_start_time(timings, now=None):
+    """Resolve UPC order-normal start time from manual or offset mode."""
+    mode = timings.get("time_mode", "manual").lower()
+    if mode == "offset":
+        offset = timings.get("order_normal_start_offset_minutes")
+        if offset is None:
+            raise ValueError(
+                "UPC time_mode 'offset' requires "
+                "order_normal_start_offset_minutes"
+            )
+        now = datetime.now() if now is None else now
+        return (now + timedelta(minutes=offset)).strftime("%H:%M")
+    if mode != "manual":
+        raise ValueError("UPC time_mode must be 'manual' or 'offset'")
+
+    start_time = timings.get("order_normal_start_time")
+    if not start_time:
+        raise ValueError(
+            "UPC time_mode 'manual' requires order_normal_start_time"
+        )
+    return start_time
+
+
 def get_product_codes(token):
 
     product_codes = parse_product_codes(token.get("create_product_codes", token.get("product_codes")))
@@ -203,10 +239,19 @@ def open_rtm_new_token(driver, step, token):
 def get_rtm_token_times(token, now=None):
     now = datetime.now() if now is None else now
     delivery_date = (now + timedelta(days=token.get("delivery_offset_days", 0))).strftime("%d/%m/%Y")
+    time_mode = token.get("time_mode", "offset").lower()
+    if time_mode == "manual":
+        session_start_time = token.get("session_start_time")
+        if not session_start_time:
+            raise ValueError("RTM time_mode 'manual' requires session_start_time")
+    elif time_mode == "offset":
+        session_start_time = (now + timedelta(minutes=token.get("session_start_offset_minutes", 5))).strftime("%H:%M")
+    else:
+        raise ValueError("RTM time_mode must be 'manual' or 'offset'")
     return (
         f"{delivery_date} {token.get('delivery_from_time', '00:00')}",
         f"{delivery_date} {token.get('delivery_to_time', '23:59')}",
-        (now + timedelta(minutes=token.get("session_start_offset_minutes", 5))).strftime("%H:%M"),
+        session_start_time,
         token.get("session_end_time", "20:00"),
     )
 
@@ -227,6 +272,76 @@ def create_rtm_token(driver, step, token):
     handle_transient_popups(driver)
 
 
+def create_intraday_token(driver, step, token):
+    """Create an Intraday token through the Token Generator page."""
+    open_trading_maintenance_page(driver, Locator.tokengenerator)
+    handle_transient_popups(driver)
+    step.capture("open_token_generator_intraday")
+
+    for element_id, value, name in (
+        (Locator.generatormarketcode, token["market_code"], "market_code"),
+        (Locator.generatorproductcode, token["product_code"], "product_code"),
+        (Locator.generatorgenerationmode, token["generation_mode"], "generation_mode"),
+    ):
+        select_bootstrap_dropdown_by_id(driver, element_id, value, exact=True)
+        step.capture(f"select_{name}_intraday")
+
+    step.click((By.XPATH, Locator.addnewtokenbtn), "click_add_new_token_intraday")
+
+    delivery_start, delivery_end = get_intraday_delivery_window(token)
+    values = (
+        (Locator.intradaydeliveryfromdate, delivery_start, "delivery_from_date"),
+        (Locator.intradaydeliverytodate, delivery_end, "delivery_to_date"),
+        (Locator.intradaytradingstarttime, token.get("trading_start_time", "00:20"), "trading_start_time"),
+        (Locator.intradaydaysbeforedelivery, str(token.get("trading_start_days_before_delivery", 1)), "days_before_delivery"),
+    )
+    for locator, value, name in values:
+        type_first_visible_input(driver, locator, value)
+        step.capture(f"enter_{name}_intraday")
+
+    step.click((By.XPATH, Locator.savetokenbtn), "save_token_intraday")
+    WebDriverWait(driver, 30).until(
+        EC.visibility_of_element_located((By.XPATH, Locator.intradaysuccessmessage))
+    )
+    step.capture("intraday_token_generated_successfully")
+    handle_transient_popups(driver)
+
+
+def create_dac_token(driver, step, token):
+    """Create a DAC token through the Token Generator page."""
+    open_trading_maintenance_page(driver, Locator.tokengenerator)
+    handle_transient_popups(driver)
+    step.capture("open_token_generator_dac")
+
+    for element_id, value, name in (
+        (Locator.generatormarketcode, token["market_code"], "market_code"),
+        (Locator.generatorproductcode, token["product_code"], "product_code"),
+        (Locator.generatorgenerationmode, token["generation_mode"], "generation_mode"),
+    ):
+        select_bootstrap_dropdown_by_id(driver, element_id, value, exact=True)
+        step.capture(f"select_{name}_dac")
+
+    step.click((By.XPATH, Locator.addnewtokenbtn), "click_add_new_token_dac")
+
+    trading_start, trading_end = get_intraday_delivery_window(token)
+    values = (
+        (Locator.dactradingfromdate, trading_start, "trading_from_date"),
+        (Locator.dactradingtodate, trading_end, "trading_to_date"),
+        (Locator.dacsessionstarttime, token.get("session_start_time", "13:00"), "session_start_time"),
+        (Locator.dacsessionendtime, token.get("session_end_time", "23:00"), "session_end_time"),
+    )
+    for locator, value, name in values:
+        type_first_visible_input(driver, locator, value)
+        step.capture(f"enter_{name}_dac")
+
+    step.click((By.XPATH, Locator.savetokenbtn), "save_token_dac")
+    WebDriverWait(driver, 30).until(
+        EC.visibility_of_element_located((By.XPATH, Locator.intradaysuccessmessage))
+    )
+    step.capture("dac_token_generated_successfully")
+    handle_transient_popups(driver)
+
+
 def create_upc_token(driver, step, token):
     open_trading_maintenance_page(driver, Locator.tokengenerator)
     handle_transient_popups(driver)
@@ -240,7 +355,7 @@ def create_upc_token(driver, step, token):
     step.click((By.XPATH, Locator.addnewtokenbtn), "click_add_new_token_upc")
     timings = token.get("upc_times", {})
     for name, locator, value in (
-        ("order_normal_start", Locator.upcorderstart, timings.get("order_normal_start_time")),
+        ("order_normal_start", Locator.upcorderstart, get_upc_order_normal_start_time(timings)),
         ("order_normal_end", Locator.upcorderend, timings.get("order_normal_end_time")),
         ("trade_start", Locator.upctradestart, timings.get("trade_session_start_time")),
         ("trade_end", Locator.upctradeend, timings.get("trade_session_end_time")),
@@ -254,6 +369,12 @@ def create_upc_token(driver, step, token):
 
 
 def run_token_setup(driver, step, token):
+    if token.get("product_type", "").upper() == "DAC":
+        create_dac_token(driver, step, token)
+        return
+    if token.get("product_type", "").upper() == "INTRADAY":
+        create_intraday_token(driver, step, token)
+        return
     if token.get("product_type", "").upper() == "UPC":
         create_upc_token(driver, step, token)
         return
@@ -291,6 +412,10 @@ def create_and_activate_token(driver, step, token):
 
     step.click((By.XPATH, Locator.addnewtokenbtn), f"click_add_new_token_{product_code.lower()}")
 
+    is_intraday = token.get("product_type", "").upper() == "INTRADAY"
+    if is_intraday:
+        delivery_start, delivery_end = get_intraday_delivery_window(token)
+    else:
         next_day, token_expiry = get_delivery_date_and_expiry(token)
 
     if token.get("product_type", "").upper() == "REC":
@@ -303,9 +428,7 @@ def create_and_activate_token(driver, step, token):
         if token.get("generation_mode") == "AnyDayUPC":
             step.type((By.XPATH, Locator.tokentradedate), today, f"enter_trade_date_{product_code.lower()}")
         timings = token.get("upc_times", {})
-        normal_start = timings.get("order_normal_start_time")
-        if normal_start is None and timings.get("order_normal_start_offset_minutes") is not None:
-            normal_start = (datetime.now() + timedelta(minutes=timings["order_normal_start_offset_minutes"])).strftime("%H:%M")
+        normal_start = get_upc_order_normal_start_time(timings)
         values = {
             Locator.upcordernormalstart: normal_start,
             Locator.upcordernormalend: timings.get("order_normal_end_time"),
@@ -317,14 +440,17 @@ def create_and_activate_token(driver, step, token):
                 continue
             type_first_visible_input(driver, locator, value)
 
-    if (
+    if is_intraday:
+        step.type((By.XPATH, Locator.tokendeliverystartdate), delivery_start, f"enter_delivery_start_date_{product_code.lower()}")
+        step.type((By.XPATH, Locator.tokendeliveryenddate), delivery_end, f"enter_delivery_end_date_{product_code.lower()}")
+    elif (
         token.get("generation_mode") not in ("WeeklyUPC", "MonthlyUPC")
         and token.get("product_type", "").upper() != "REC"
     ):
         step.type((By.XPATH, Locator.tokendeliverystartdate), next_day, f"enter_delivery_start_date_{product_code.lower()}")
         step.type((By.XPATH, Locator.tokendeliveryenddate), next_day, f"enter_delivery_end_date_{product_code.lower()}")
 
-    if token.get("generation_mode") not in ("WeeklyUPC", "MonthlyUPC"):
+    if not is_intraday and token.get("generation_mode") not in ("WeeklyUPC", "MonthlyUPC"):
         step.type((By.XPATH, Locator.tokenexpirydate), token_expiry, f"enter_token_expiry_date_{product_code.lower()}")
 
     step.click((By.XPATH, Locator.savetokenbtn), f"save_token_{product_code.lower()}")
@@ -334,6 +460,7 @@ def create_and_activate_token(driver, step, token):
         step.click((By.XPATH, Locator.tokengeneratorresetbtn), f"reset_token_generator_{product_code.lower()}")
         return
 
+    if not is_intraday:
         complete_time_session_edits_from_saved_token(driver, step, token)