ObjectStore test cases

To test the store_items function, you can use Python's unittest.mock module to create a mock object for self.algorithm.ObjectStore. This allows you to simulate the behavior of the ObjectStore without needing to interact with the actual ObjectStore.

Here's an example of how you can do this:

import unittest
from unittest.mock import MagicMock, patch

class TestObjectStorageManagement(unittest.TestCase):
    def setUp(self):
        self.algorithm = MagicMock()
        self.object_storage = ObjectStorageManagement(self.algorithm)
        self.mock_data = [
            {
                "Rank": 1,
                "EffectiveDate": "2023-01-01",
            },
            # Add more items as needed
        ]

    @patch('ObjectStorageManagement.json.dumps')
    @patch('ObjectStorageManagement.ObjectStore.SaveBytes')
    def test_store_items(self, mock_save_bytes, mock_dumps):
        # Arrange
        mock_dumps.return_value.encode.return_value = 'mock_json'
        self.object_storage.items = self.mock_data
        self.object_storage.trade_planning_key = 'mock_key'

        # Act
        self.object_storage.store_items()

        # Assert
        mock_dumps.assert_called_once_with(self.mock_data, default=self.object_storage.serialize_date)
        mock_save_bytes.assert_called_once_with('mock_key', 'mock_json')
        self.algorithm.Debug.assert_called_once_with(f"Stored {len(self.mock_data)} items in ObjectStore under tag 'mock_key'.")

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

In this example, we're using the patch decorator to mock the json.dumps and ObjectStore.SaveBytes methods. We then check that these methods were called with the expected arguments.

Please note that this is a general Python unit testing approach. The actual implementation may vary depending on the specifics of your ObjectStorageManagement class and serialize_date method.

For more information on how to use the ObjectStore in QuantConnect, you can refer to the QuantConnect documentation.

FAILED [100%]items_json (raw): <MagicMock name='mock.ObjectStore.Read()' id='2568337609328'>

test_object_store.py:30 (TestObjectStorageManagement.test_store_items)
self = <test_object_store.TestObjectStorageManagement testMethod=test_store_items>

   def setUp(self):
       self.algorithm = MagicMock()
>       self.object_storage = ObjectStorageManagement(self.algorithm)

test_object_store.py:11: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
object_store.py:9: in __init__
   self.items = self.load_items()
object_store.py:15: in load_items
   res = json.loads(items_json)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

s = <MagicMock name='mock.ObjectStore.Read()' id='2568337609328'>, cls = None
object_hook = None, parse_float = None, parse_int = None, parse_constant = None
object_pairs_hook = None, kw = {}

   def loads(s, *, cls=None, object_hook=None, parse_float=None,
           parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):

The error message indicates that the json.loads function is trying to parse a MagicMock object, which it can't do. This is likely because the ObjectStore.Read method is being called somewhere in your load_items method and it's returning a MagicMock instead of a JSON string.

To fix this, you need to set a return value for ObjectStore.Read in your test setup. Here's an example of how you can do this:

def setUp(self):
    self.algorithm = MagicMock()
    self.algorithm.ObjectStore.Read.return_value = json.dumps(self.mock_data)
    self.object_storage = ObjectStorageManagement(self.algorithm)

In this example, ObjectStore.Read will return a JSON string of self.mock_data when it's called. This should allow json.loads to parse the returned value correctly.

Please note that this is a general Python unit testing approach. The actual implementation may vary depending on the specifics of your ObjectStorageManagement class and load_items method.

For more information on how to use the ObjectStore in QuantConnect, you can refer to the QuantConnect documentation.

thing = <class 'object_store.ObjectStorageManagement'>, comp = 'algorithm'
import_path = 'object_store.ObjectStorageManagement.algorithm'

   def _dot_lookup(thing, comp, import_path):
       try:
           return getattr(thing, comp)
       except AttributeError:
>           __import__(import_path)
E           ModuleNotFoundError: No module named 'object_store.ObjectStorageManagement'; 'object_store' is not a package
 

The error message indicates that Python is unable to find a module named 'object_store.ObjectStorageManagement'. This could be due to several reasons:

1. The file object_store.py is not in the same directory as the script you are running. Python needs to be able to find this file in order to import the ObjectStorageManagement class from it.

2. The object_store directory does not contain an __init__.py file. This file is required for Python to recognize the directory as a package.

3. The ObjectStorageManagement class does not exist in the object_store.py file. Make sure the class is defined in this file and that it's spelled correctly.

Here's an example of how you can import the ObjectStorageManagement class if object_store.py is in the same directory as your script:

from object_store import ObjectStorageManagement

If object_store.py is in a different directory, you'll need to add that directory to the Python path:

import sys
sys.path.insert(0, '/path/to/directory')

from object_store import ObjectStorageManagement

Replace '/path/to/directory' with the actual path to the directory containing object_store.py.

Please note that this is a general Python import issue. The actual solution may vary depending on your project structure and environment.

For more information on how to use the ObjectStore in QuantConnect, you can refer to the QuantConnect documentation.

I am running the test case locally on my machine. How to setup Python project on Pycharm IDE so I can run test cases locally

To set up a Python project on PyCharm IDE and run test cases locally, you can follow these steps:

1. Open PyCharm and create a new project or open an existing one.

2. Make sure you have the Professional edition of PyCharm as it supports remote debugging functionality which is required for local debugging with QuantConnect's LEAN engine.

3. Set up local autocomplete for Python in PyCharm. Open a project directory, generated by the CLI, with PyCharm and wait for the project to load. Wait for PyCharm to index all packages and autocomplete starts working. Update your project to include the required imports (source).

4. To debug your Python algorithms locally in PyCharm, follow these steps as mentioned in the QuantConnect Documentation:

   • Open the directory containing the main.py file in a new PyCharm window. It is important that you open the project directory itself, not your workspace.
   • Start debugging using the Debug with Lean CLI run configuration (this configuration is created when you create a new project with the CLI).
   • Run the lean backtest command with the --debug pycharm option.

     $ lean backtest "My Project" --debug pycharm
     

5. For running test cases, you can use Python's built-in unittest module. In PyCharm, you can right-click on the test file or the directory containing the test files and select 'Run Unittests in...'.

Please note that this is a general guide for setting up a Python project in PyCharm and running test cases. The actual steps may vary depending on your specific project and test cases.