Allow submitting associated test parameters alongside results

Rather than simply giving a single test name and run values, this commit
extends the "tests" array that can be submitted with an optional
"params" dict containing parameter name/value pairs. This can be useful
for tests that are parameterised by e.g. an array length or speed
setting.

An example of setting parameters as part of a submission:

        {
          "format_version": "2",
          "machine": { ...  },
          "run": { ...  },
          "tests": [
            {
              "name": "bosphorus_1080p_30fps_8bit_fast_limit503",
              "runtime": 341.0969772338867,
              "params": {
                "input_file": "Bosphorus_1920x1080.y4m",
                "fps": "30",
                "bit_depth": "8",
                "quality_mode": "fast",
                "limit": "503"
              }
            },
            ...
          ]
        }

For this particular commit the parameters are unused beyond being
settable and accessible via the API methods e.g.
/api/db_default/v4/foo/tests. In future these parameters may be used for
smarter grouping of data or graphing different parameter sets within a
run rather than simply examining a single test case over time.

Change-Id: I23af95e490f71e618080eb94041b649bf9d18ee4

Author: georges-arm

lnt/server/db/migrations/upgrade_19_to_20.py

@@ -0,0 +1,40 @@
+# Add new TestParam table per db
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, Table, ForeignKey, LargeBinary, Index, select, MetaData
+from lnt.server.db.migrations.util import introspect_table, rename_table
+from sqlalchemy.orm import relation, mapper, Session
+
+
+Base = declarative_base()
+
+
+def update_testsuite(session, meta, db_key_name):
+    class Test(object):
+        pass
+
+    test_table = Table('%s_Test' % db_key_name, meta, autoload=True)
+    mapper(Test, test_table)
+
+    class TestParam(Base):
+        __tablename__ = db_key_name + '_TestParam'
+        id = Column("ID", Integer, primary_key=True)
+        name = Column("Name", String(128), index=True)
+        value = Column("Value", String(128))
+        test_id = Column("TestID", Integer, ForeignKey(Test.id), index=True)
+        test = relation(Test)
+
+    test_table.params = relation(TestParam, back_populates='test',
+                                 cascade="all, delete-orphan")
+
+    Base.metadata.create_all(session)
+
+
+def upgrade(engine):
+    test_suite = introspect_table(engine, 'TestSuite')
+    meta = MetaData(bind=engine)
+
+    with Session(engine) as session, session.begin():
+        db_keys = list(session.execute(select([test_suite])))
+
+        for suite in db_keys:
+            update_testsuite(session, meta, suite[2])

lnt/server/db/testsuitedb.py

@@ -438,14 +438,48 @@ def __init__(self, name):
 
             def __repr__(self):
                 return '%s_%s%r' % (db_key_name, self.__class__.__name__,
-                                    (self.id, self.name))
+                                    (self.id, self.name, self.params))
 
-            def __json__(self, include_id=True):
+            def __json__(self, include_id=True, include_params=True):
                 result = {'name': self.name}
                 if include_id:
                     result['id'] = self.id
+                if include_params:
+                    result["params"] = {p.name: p.value for p in self.params}
                 return result
 
+        class TestParam(self.base, ParameterizedMixin):
+            __tablename__ = db_key_name + '_TestParam'
+            # utf8_bin for case sensitive compare
+            __table_args__ = {'mysql_collate': 'utf8_bin'}
+            id = Column("ID", Integer, primary_key=True)
+            name = Column("Name", String(128), index=True)
+            value = Column("Value", String(128))
+
+            test_id = Column("TestID", Integer, ForeignKey(Test.id), index=True)
+            test = relation(Test)
+
+            def __init__(self, test, name, value):
+                self.id = None
+                self.test = test
+                self.name = name
+                self.value = value
+
+            def __repr__(self):
+                return '%s_%s%r' % (db_key_name, self.__class__.__name__,
+                                    (self.id, self.test, self.name, self.value))
+
+            def __json__(self):
+                return {
+                    "id": self.id,
+                    "test": self.test.__json__(include_params=False),
+                    "name": self.name,
+                    "value": self.value,
+                }
+
+        Test.params = relation(TestParam, back_populates='test',
+                               cascade="all, delete-orphan")
+
         class Profile(self.base):
             __tablename__ = db_key_name + '_Profile'
 
@@ -775,6 +809,7 @@ def __json__(self):
         self.Machine = Machine
         self.Run = Run
         self.Test = Test
+        self.TestParam = TestParam
         self.Profile = Profile
         self.Sample = Sample
         self.Order = Order
@@ -1067,9 +1102,24 @@ def is_profile_only(td):
                 test_cache[name] = test
                 session.add(test)
 
+            if "params" in test_data:
+                for param_name, param_value in test_data["params"].items():
+                    matching_params = [p for p in test.params if p.name == param_name]
+                    assert len(matching_params) <= 1
+                    if len(matching_params) == 0:
+                        # Add new parameter definition.
+                        param = self.TestParam(test, param_name, param_value)
+                        session.add(param)
+                    elif param_value is not None:
+                        # Update existing parameter definition.
+                        matching_params[0].value = param_value
+                    else:
+                        # Erase previously existing parameter definition.
+                        session.delete(matching_params[0])
+
             samples = []
             for key, values in test_data.items():
-                if key == 'name' or key == "id" or key.endswith("_id"):
+                if key in ("name", "id", "params") or key.endswith("_id"):
                     continue
                 field = field_dict.get(key)
                 if field is None and key != 'profile':

lnt/server/ui/views.py

@@ -121,6 +121,7 @@ def index():
 ###
 # Database Actions
 def _do_submit():
+    print("hi!")
     assert request.method == 'POST'
     input_file = request.files.get('file')
     input_data = request.form.get('input_data')