Stacked @card v1.2 : Test cases for Multiple @cards

metaflow/plugins/__init__.py

@@ -187,16 +187,29 @@ def _merge_lists(base, overrides, attr):
 
 # Cards
 from .cards.card_modules.basic import DefaultCard, TaskSpecCard, ErrorCard, BlankCard
-from .cards.card_modules.test_cards import TestErrorCard, TestTimeoutCard, TestMockCard
+from .cards.card_modules.test_cards import (
+    TestErrorCard,
+    TestTimeoutCard,
+    TestMockCard,
+    TestPathSpecCard,
+    TestEditableCard,
+    TestEditableCard2,
+    TestNonEditableCard,
+)
 from .cards.card_modules import MF_EXTERNAL_CARDS
 
 CARDS = [
     DefaultCard,
     TaskSpecCard,
     ErrorCard,
+    BlankCard,
     TestErrorCard,
     TestTimeoutCard,
     TestMockCard,
+    TestPathSpecCard,
+    TestEditableCard,
+    TestEditableCard2,
+    TestNonEditableCard,
     BlankCard,
 ] + MF_EXTERNAL_CARDS
 # Sidecars

metaflow/plugins/cards/card_client.py

@@ -37,6 +37,7 @@ def __init__(
         card_ds,
         type,
         path,
+        hash,
         id=None,
         html=None,
         created_on=None,
@@ -51,6 +52,7 @@ def __init__(
         self._card_id = id
 
         # public attributes
+        self.hash = hash
         self.type = type
         self.from_resumed = from_resumed
         self.origin_pathspec = origin_pathspec
@@ -131,6 +133,7 @@ def _get_card(self, index):
             self._card_ds,
             card_info.type,
             path,
+            card_info.hash,
             id=card_info.id,
             html=None,
             created_on=None,

metaflow/plugins/cards/card_modules/test_cards.py

@@ -1,6 +1,69 @@
 from .card import MetaflowCard, MetaflowCardComponent
 
 
+class TestStringComponent(MetaflowCardComponent):
+    def __init__(self, text):
+        self._text = text
+
+    def render(self):
+        return str(self._text)
+
+
+class TestPathSpecCard(MetaflowCard):
+    type = "test_pathspec_card"
+
+    def render(self, task):
+        import random
+        import string
+
+        return "%s %s" % (
+            task.pathspec,
+            "".join(
+                random.choice(string.ascii_uppercase + string.digits) for _ in range(6)
+            ),
+        )
+
+
+class TestEditableCard(MetaflowCard):
+    type = "test_editable_card"
+
+    seperator = "$&#!!@*"
+
+    ALLOW_USER_COMPONENTS = True
+
+    def __init__(self, options={}, components=[], graph=None):
+        self._components = components
+
+    def render(self, task):
+        return self.seperator.join([str(comp) for comp in self._components])
+
+
+class TestEditableCard2(MetaflowCard):
+    type = "test_editable_card_2"
+
+    seperator = "$&#!!@*"
+
+    ALLOW_USER_COMPONENTS = True
+
+    def __init__(self, options={}, components=[], graph=None):
+        self._components = components
+
+    def render(self, task):
+        return self.seperator.join([str(comp) for comp in self._components])
+
+
+class TestNonEditableCard(MetaflowCard):
+    type = "test_non_editable_card"
+
+    seperator = "$&#!!@*"
+
+    def __init__(self, options={}, components=[], graph=None):
+        self._components = components
+
+    def render(self, task):
+        return self.seperator.join([str(comp) for comp in self._components])
+
+
 class TestMockCard(MetaflowCard):
     type = "test_mock_card"
 

test/core/metaflow_test/__init__.py

@@ -128,6 +128,9 @@ def assert_log(self, step, logtype, value, exact_match=True):
     def get_card(self, step, task, card_type):
         raise NotImplementedError()
 
+    def list_cards(self, step, task, card_type=None):
+        raise NotImplementedError()
+
 
 def new_checker(flow):
     from . import cli_check, metadata_check

test/core/metaflow_test/cli_check.py

@@ -111,12 +111,23 @@ def assert_log(self, step, logtype, value, exact_match=True):
             )
         return True
 
-    def assert_card(self, step, task, card_type, value, exact_match=True):
+    def assert_card(
+        self,
+        step,
+        task,
+        card_type,
+        value,
+        card_hash=None,
+        card_id=None,
+        exact_match=True,
+    ):
         from metaflow.plugins.cards.exception import CardNotPresentException
 
         no_card_found_message = CardNotPresentException.headline
         try:
-            card_data = self.get_card(step, task, card_type)
+            card_data = self.get_card(
+                step, task, card_type, card_hash=card_hash, card_id=card_id
+            )
         except subprocess.CalledProcessError as e:
             if no_card_found_message in e.output.decode("utf-8").strip():
                 card_data = None
@@ -131,7 +142,33 @@ def assert_card(self, step, task, card_type, value, exact_match=True):
             )
         return True
 
-    def get_card(self, step, task, card_type):
+    def list_cards(self, step, task, card_type=None):
+        from metaflow.plugins.cards.exception import CardNotPresentException
+
+        no_card_found_message = CardNotPresentException.headline
+        try:
+            card_data = self._list_cards(step, task=task, card_type=card_type)
+            card_data = json.loads(card_data)
+        except subprocess.CalledProcessError as e:
+            if no_card_found_message in e.output.decode("utf-8").strip():
+                card_data = None
+            else:
+                raise e
+        return card_data
+
+    def _list_cards(self, step, task=None, card_type=None):
+        pathspec = "%s/%s" % (self.run_id, step)
+        if task is not None:
+            pathspec = "%s/%s/%s" % (self.run_id, step, task)
+        cmd = ["--quiet", "card", "list", pathspec, "--as-json"]
+        if card_type is not None:
+            cmd.extend(["--type", card_type])
+
+        return self.run_cli(cmd, capture_output=True, pipe_error_to_output=True).decode(
+            "utf-8"
+        )
+
+    def get_card(self, step, task, card_type, card_hash=None, card_id=None):
         cmd = [
             "--quiet",
             "card",
@@ -140,6 +177,12 @@ def get_card(self, step, task, card_type):
             "--type",
             card_type,
         ]
+
+        if card_hash is not None:
+            cmd.extend(["--hash", card_hash])
+        if card_id is not None:
+            cmd.extend(["--id", card_id])
+
         return self.run_cli(cmd, capture_output=True, pipe_error_to_output=True).decode(
             "utf-8"
         )

test/core/metaflow_test/metadata_check.py

@@ -109,21 +109,56 @@ def assert_log(self, step, logtype, value, exact_match=True):
                 % (step, logtype, repr(value), logtype, repr(log_value))
             )
 
-    def assert_card(self, step, task, card_type, value, exact_match=True):
+    def list_cards(self, step, task, card_type=None):
         from metaflow.plugins.cards.exception import CardNotPresentException
 
         try:
             card_iter = self.get_card(step, task, card_type)
         except CardNotPresentException:
             card_iter = None
+
+        if card_iter is None:
+            return
+        pathspec = self.run[step][task].pathspec
+        list_data = dict(pathspec=pathspec, cards=[])
+        if len(card_iter) > 0:
+            list_data["cards"] = [
+                dict(
+                    hash=card.hash,
+                    id=card.id,
+                    type=card.type,
+                    filename=card.path.split("/")[-1],
+                )
+                for card in card_iter
+            ]
+        return list_data
+
+    def assert_card(
+        self,
+        step,
+        task,
+        card_type,
+        value,
+        card_hash=None,
+        card_id=None,
+        exact_match=True,
+    ):
+        from metaflow.plugins.cards.exception import CardNotPresentException
+
+        try:
+            card_iter = self.get_card(step, task, card_type, card_id=card_id)
+        except CardNotPresentException:
+            card_iter = None
         card_data = None
-        # FUTURE FIXME:
-        # We are checking the first card here.
-        # Not all possible present cards
-        # This should change in the future when we support many decorator.
+        # Since there are many cards possible for a taskspec, we check for hash to assert a single card.
+        # If the id argument is present then there will be a single cards anyways.
         if card_iter is not None:
             if len(card_iter) > 0:
-                card_data = card_iter[0].get()
+                if card_hash is None:
+                    card_data = card_iter[0].get()
+                else:
+                    card_filter = [c for c in card_iter if card_hash in c.hash]
+                    card_data = None if len(card_filter) == 0 else card_filter[0].get()
         if (exact_match and card_data != value) or (
             not exact_match and value not in card_data
         ):
@@ -136,8 +171,8 @@ def assert_card(self, step, task, card_type, value, exact_match=True):
     def get_log(self, step, logtype):
         return "".join(getattr(task, logtype) for task in self.run[step])
 
-    def get_card(self, step, task, card_type):
+    def get_card(self, step, task, card_type, card_id=None):
         from metaflow.cards import get_cards
 
-        iterator = get_cards(self.run[step][task], type=card_type)
+        iterator = get_cards(self.run[step][task], type=card_type, id=card_id)
         return iterator