Integration test for results tracker. #1

Author: Lakshmi Kannan

st2actions/st2actions/query/base.py

@@ -115,5 +115,6 @@ def __init__(self, id, execution_id, query_context):
         self.query_context = query_context
         self.id = id
 
-    def from_model(self, model):
+    @classmethod
+    def from_model(cls, model):
         return QueryContext(model.id, model.execution_id, model.query_context)

st2actions/st2actions/resultstracker.py

@@ -105,7 +105,8 @@ def _bootstrap(self):
                 continue
             query_module_name = state_db.query_module
             querier = self.get_querier(query_module_name)
-            query_contexts_dict[querier].append(context)
+            if querier is not None:
+                query_contexts_dict[querier].append(context)
 
         for querier, contexts in six.iteritems(query_contexts_dict):
             LOG.info('Found %d pending actions for query module %s', len(contexts), querier)
@@ -120,7 +121,7 @@ def get_querier(self, query_module_name):
             except:
                 LOG.exception('Failed importing query module: %s', query_module_name)
                 self._failed_imports.add(query_module_name)
-                continue
+                self._queriers[query_module_name] = None
             else:
                 self._queriers[query_module_name] = querier.get_instance()
 

st2actions/tests/integration/test_resultstracker.py

@@ -0,0 +1,28 @@
+from st2actions.resultstracker import ResultsTracker
+from st2tests.base import (DbTestCase, EventletTestCase)
+from st2tests.fixturesloader import FixturesLoader
+
+FIXTURES_PACK = 'generic'
+FIXTURES = {'actionstates': ['state1.json', 'state2.json']}
+loader = FixturesLoader()
+
+
+class ResultsTrackerTests(EventletTestCase, DbTestCase):
+    states = None
+    models = None
+
+    @classmethod
+    def setUpClass(cls):
+        super(ResultsTrackerTests, cls).setUpClass()
+        DbTestCase.setUpClass()
+        ResultsTrackerTests.models = loader.save_fixtures_to_db(fixtures_pack=FIXTURES_PACK,
+                                                                fixtures_dict=FIXTURES)
+        ResultsTrackerTests.states = ResultsTrackerTests.models['actionstates']
+
+    def test_bootstrap(self):
+        tracker = ResultsTracker()
+        tracker._bootstrap()
+
+    @classmethod
+    def tearDownClass(cls):
+        loader.delete_models_from_db(ResultsTrackerTests.models)

st2actions/tests/resources/test_querymodule.py

@@ -20,6 +20,7 @@
 from st2common import log as logging
 from st2common.models.base import BaseAPI
 from st2common.models.db.action import (RunnerTypeDB, ActionDB, ActionExecutionDB)
+from st2common.models.db.action import ActionExecutionStateDB
 from st2common.constants.action import ACTIONEXEC_STATUSES
 
 
@@ -281,3 +282,51 @@ def to_model(cls, execution):
         model.callback = getattr(execution, 'callback', dict())
         model.result = getattr(execution, 'result', None)
         return model
+
+
+class ActionExecutionStateAPI(BaseAPI):
+    """
+    System entity that represents state of an action in the system.
+    This is used only in tests for now.
+    """
+    model = ActionExecutionStateDB
+    schema = {
+        "title": "ActionExecutionState",
+        "description": "Execution state of an action.",
+        "type": "object",
+        "properties": {
+            "id": {
+                "description": "The unique identifier for the action execution state.",
+                "type": "string"
+            },
+            "execution_id": {
+                "type": "string",
+                "description": "ID of the action execution.",
+                "required": True
+            },
+            "query_context": {
+                "type": "object",
+                "description": "query context to be used by querier.",
+                "required": True
+            },
+            "query_module": {
+                "type": "string",
+                "description": "Name of the query module.",
+                "required": True
+            }
+        },
+        "additionalProperties": False
+    }
+
+    @classmethod
+    def from_model(cls, model):
+        doc = super(cls, cls)._from_model(model)
+        return cls(**doc)
+
+    @classmethod
+    def to_model(cls, state):
+        model = super(cls, cls).to_model(state)
+        model.query_module = state.query_module
+        model.execution_id = state.execution_id
+        model.query_context = state.query_context
+        return model

st2common/st2common/models/api/action.py

@@ -0,0 +1,7 @@
+{
+    "execution_id": "549dcfda95e3fc7a9b0912ee",
+    "query_context": {
+        "id":"661491fa-3e17-48cf-bc92-05ecc501d700"
+    },
+    "query_module": "tests.resources.query_module"
+}

st2tests/st2tests/fixtures/generic/actionstates/state1.json

@@ -0,0 +1,7 @@
+{
+    "execution_id": "549dcfda95e3fc7a9b0912ef",
+    "query_context": {
+        "id":"661491fa-3e17-48cf-bc92-05ecc501d701"
+    },
+    "query_module": "tests.resources.query_module"
+}

st2tests/st2tests/fixtures/generic/actionstates/state2.json

@@ -20,26 +20,30 @@
 
 from st2common.content.loader import MetaLoader
 
-from st2common.models.api.action import (ActionAPI, ActionExecutionAPI, RunnerTypeAPI)
+from st2common.models.api.action import (ActionAPI, ActionExecutionAPI, ActionExecutionStateAPI,
+                                         RunnerTypeAPI)
 from st2common.models.api.history import (ActionExecutionHistoryAPI)
 from st2common.models.api.reactor import (TriggerAPI, TriggerTypeAPI)
 from st2common.models.api.rule import (RuleAPI)
 
-from st2common.models.db.action import (ActionDB, ActionExecutionDB, RunnerTypeDB)
+from st2common.models.db.action import (ActionDB, ActionExecutionDB, ActionExecutionStateDB,
+                                        RunnerTypeDB)
 from st2common.models.db.history import (ActionExecutionHistoryDB)
 from st2common.models.db.reactor import (RuleDB, TriggerDB, TriggerTypeDB)
 
-from st2common.persistence.action import (Action, ActionExecution, RunnerType)
+from st2common.persistence.action import (Action, ActionExecution, ActionExecutionState,
+                                          RunnerType)
 from st2common.persistence.history import (ActionExecutionHistory)
 from st2common.persistence.reactor import (Rule, Trigger, TriggerType)
 
-ALLOWED_DB_FIXTURES = ['actions', 'executions', 'history', 'rules', 'runners',
+ALLOWED_DB_FIXTURES = ['actions', 'actionstates', 'executions', 'history', 'rules', 'runners',
                        'triggertypes', 'triggers']
 ALLOWED_FIXTURES = copy.copy(ALLOWED_DB_FIXTURES)
 ALLOWED_FIXTURES.extend(['actionchains', 'workflows'])
 
 FIXTURE_DB_MODEL = {
     'actions': ActionDB,
+    'actionstates': ActionExecutionStateDB,
     'executions': ActionExecutionDB,
     'history': ActionExecutionHistoryDB,
     'rules': RuleDB,
@@ -50,6 +54,7 @@
 
 FIXTURE_API_MODEL = {
     'actions': ActionAPI,
+    'actionstates': ActionExecutionStateAPI,
     'executions': ActionExecutionAPI,
     'history': ActionExecutionHistoryAPI,
     'rules': RuleAPI,
@@ -61,6 +66,7 @@
 
 FIXTURE_PERSISTENCE_MODEL = {
     'actions': Action,
+    'actionstates': ActionExecutionState,
     'executions': ActionExecution,
     'history': ActionExecutionHistory,
     'rules': Rule,