Esempio n. 1
0
    def test_card_type(self):
        from mnemosyne.libmnemosyne.card_types.cloze import ClozePlugin

        for plugin in self.plugins():
            if isinstance(plugin, ClozePlugin):
                cloze_plugin = plugin
                plugin.activate()
                break

        fact_data = {"text": "[foo]"}
        card_type_1 = self.card_type_by_id("5")
        card = self.controller().create_new_cards(fact_data, card_type_1, grade=-1, tag_names=["default"])[0]
        assert self.database().active_count() == 1

        c = DefaultCriterion(self.mnemosyne.component_manager)
        c.deactivated_card_type_fact_view_ids = set([(card_type_1.id, card_type_1.fact_views[0].id)])
        c.active_tag__ids = set()
        c.forbidden_tag__ids = set()
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 0

        self.database().delete_fact_and_related_data(card.fact)
        plugin.deactivate()
        c = self.database().current_activity_criterion()
        assert len(c.deactivated_card_type_fact_view_ids) == 0
Esempio n. 2
0
    def get_criterion(self):

        """Build the criterion from the information the user entered in the
        widget.

        """
        
        criterion = DefaultCriterion(self.component_manager)
        # Card types and fact views.
        for item, card_type_fact_view_ids in \
                self.card_type_fact_view_ids_for_node_item.iteritems():
            if item.checkState(0) == QtCore.Qt.Unchecked:
                criterion.deactivated_card_type_fact_view_ids.add(\
                    card_type_fact_view_ids)
        # Tag tree contains active tags.
        if self.active_or_forbidden.currentIndex() == 0: 
            for item, tag in self.tag_for_node_item.iteritems():
                if item.checkState(0) == QtCore.Qt.Checked:
                    criterion.active_tag__ids.add(tag._id)
            criterion.forbidden_tags = set()
        # Tag tree contains forbidden tags.
        else:
            for item, tag in self.tag_for_node_item.iteritems():
                if item.checkState(0) == QtCore.Qt.Checked:
                    criterion.forbidden_tag__ids.add(tag._id)
            criterion.active_tags = set(self.tag_for_node_item.values())
        return criterion
Esempio n. 3
0
 def test_activate_cards_3(self):
     fact_data = {"q": "question",
                  "a": "answer"}
     card_type_1 = self.card_type_by_id("1")
     card = self.controller().create_new_cards(fact_data, card_type_1,
        grade=-1, tag_names=["tag1"])[0]
     self.review_controller().new_question()
     
     assert self.review_controller().card == card
     assert self.review_controller().get_counters() == (0, 1, 1)
     
     fact_data = {"q": "question2",
                  "a": "answer2"}
     card_type_2 = self.card_type_by_id("2")
     cards = self.controller().create_new_cards(fact_data, card_type_2,
        grade=-1, tag_names=["tag2"])
     
     c = DefaultCriterion(self.mnemosyne.component_manager)
     c.deactivated_card_type_fact_view_ids = set()
     c.active_tag__ids = set([self.database().get_or_create_tag_with_name("tag2")._id])
     c.forbidden_tags__ids = set()
     self.database().set_current_activity_criterion(c)
     self.review_controller().reset_but_try_to_keep_current_card()
     self.review_controller().reload_counters()
     
     assert self.review_controller().card != card
     assert self.review_controller().get_counters() == (0, 2, 2)
Esempio n. 4
0
    def test_activate_cards_new_2(self):
        fact_data = {"q": "question", "a": "answer"}
        card_type_1 = self.card_type_by_id("1")
        self.controller().create_new_cards(fact_data, card_type_1, grade=-1, tag_names=["default"])
        assert self.database().active_count() == 1

        c = DefaultCriterion(self.mnemosyne.component_manager)
        c.deactivated_card_type_fact_view_ids = set([(card_type_1.id, card_type_1.fact_views[0].id)])
        c.active_tag__ids = set()
        c.forbidden_tag__ids = set()
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 0

        fact_data = {"q": "question2", "a": "answer2"}
        card_type_1 = self.card_type_by_id("1")
        self.controller().create_new_cards(fact_data, card_type_1, grade=-1, tag_names=["default"])
        assert self.database().active_count() == 0
Esempio n. 5
0
    def test_cached_scheduler_count(self):
        fact_data = {"q": "question",
                     "a": "answer"}
        card_type_1 = self.card_type_by_id("1")
        self.controller().create_new_cards(fact_data, card_type_1,
           grade=-1, tag_names=["tag"])
        assert self.database().active_count() == 1
        self.review_controller().new_question()
        assert self.review_controller().active_count == 1        

        c = DefaultCriterion(self.mnemosyne.component_manager)
        c.deactivated_card_type_fact_view_ids = set()
        c.active_tag__ids = set()
        c.forbidden_tag__ids = set()
        self.database().set_current_activity_criterion(c)
        self.review_controller().reset_but_try_to_keep_current_card()
        assert self.database().active_count() == 0
        assert self.review_controller().active_count == 0        
Esempio n. 6
0
    def test_activate_cards_edit(self):
        fact_data = {"q": "question3", "a": "answer3"}
        card_type_1 = self.card_type_by_id("1")
        card = self.controller().create_new_cards(fact_data, card_type_1, grade=-1, tag_names=["forbidden"])[0]
        assert self.database().active_count() == 1

        c = DefaultCriterion(self.mnemosyne.component_manager)
        c.deactivated_card_type_fact_view_ids = set()
        c.active_tag__ids = set()
        c.forbidden_tag__ids = set([self.database().get_or_create_tag_with_name("forbidden")._id])
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 0

        card_type_2 = self.card_type_by_id("2")
        self.controller().update_related_cards(
            card.fact, card.fact.data, card_type_2, new_tag_names=["allowed"], correspondence=[]
        )
        assert self.database().active_count() == 2

        c = list(self.database().get_activity_criteria())[0]
        assert len(c.forbidden_tag__ids) == 0
        assert len(c.active_tag__ids) == 1
Esempio n. 7
0
    def test_activate_cards_2(self):
        fact_data = {"q": "question", "a": "answer"}
        card_type_1 = self.card_type_by_id("1")
        self.controller().create_new_cards(fact_data, card_type_1, grade=-1, tag_names=["active", "forbidden"])
        assert self.database().active_count() == 1

        c = DefaultCriterion(self.mnemosyne.component_manager)
        c.deactivated_card_type_fact_view_ids = set()
        c.active_tag__ids = set([self.database().get_or_create_tag_with_name("active")._id])
        c.forbidden_tags__ids = set()
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 1

        c = DefaultCriterion(self.mnemosyne.component_manager)
        c.deactivated_card_type_fact_view_ids = set()
        c.active_tag__ids = set([self.database().get_or_create_tag_with_name("active")._id])
        c.forbidden_tag__ids = set([self.database().get_or_create_tag_with_name("forbidden")._id])
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 0
Esempio n. 8
0
def activate():
    from mnemosyne.libmnemosyne.activity_criteria.default_criterion import \
     DefaultCriterion
    card_type_2 = mnemosyne.card_type_by_id("2")
    c = DefaultCriterion(mnemosyne.component_manager)
    c.active_tags__ids = set([mnemosyne.database().get_or_create_tag_with_name("default")._id])
    c.forbidden_tag__ids = set()
    c.deactivated_card_type_fact_view_ids = \
        set([(card_type_2.id, card_type_2.fact_views[0].id)])
    c.active_tag__ids = set([mnemosyne.database().get_or_create_tag_with_name("default")._id])
    c.forbidden_tags__ids = set()
    mnemosyne.database().set_current_activity_criterion(c)  
Esempio n. 9
0
    def test_activate_cards_1(self):
        fact_data = {"q": "question", "a": "answer"}
        card_type_1 = self.card_type_by_id("1")
        self.controller().create_new_cards(fact_data, card_type_1, grade=-1, tag_names=["default"])
        assert self.database().active_count() == 1

        fact_data = {"q": "question", "a": "answer"}
        card_type_2 = self.card_type_by_id("2")
        self.controller().create_new_cards(fact_data, card_type_2, grade=-1, tag_names=["default"])
        assert self.database().active_count() == 3

        c = DefaultCriterion(self.mnemosyne.component_manager)
        c.deactivated_card_type_fact_view_ids = set()
        c.active_tag__ids = set([self.database().get_or_create_tag_with_name("default")._id])
        c.forbidden_tags__ids = set()
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 3

        c.deactivated_card_type_fact_view_ids = set([(card_type_2.id, card_type_2.fact_views[0].id)])
        c.active_tag__ids = set([self.database().get_or_create_tag_with_name("default")._id])
        c.forbidden_tags__ids = set()
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 2

        c = DefaultCriterion(self.mnemosyne.component_manager)
        c.deactivated_card_type_fact_view_ids = set()
        c.active_tag__ids = set([self.database().get_or_create_tag_with_name("default2")._id])
        c.forbidden_tags__ids = set()
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 0

        fact_data = {"q": "question2", "a": "answer2"}
        self.controller().create_new_cards(fact_data, card_type_2, grade=-1, tag_names=["default2"])
        c.deactivated_card_type_fact_view_ids = set()
        c.active_tag__ids = set([self.database().get_or_create_tag_with_name("default2")._id])
        c.forbidden_tags__ids = set()
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 2

        fact_data = {"q": "question3", "a": "answer3"}
        self.controller().create_new_cards(fact_data, card_type_2, grade=-1, tag_names=["default3", "default4"])
        c.deactivated_card_type_fact_view_ids = set()
        c.active_tag__ids = set([self.database().get_or_create_tag_with_name("default3")._id])
        c.forbidden_tags__ids = set()
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 2

        c.deactivated_card_type_fact_view_ids = set([(card_type_2.id, card_type_2.fact_views[0].id)])
        c.active_tag__ids = set([self.database().get_or_create_tag_with_name("default3")._id])
        c.forbidden_tags__ids = set()
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 1

        c.deactivated_card_type_fact_view_ids = set(
            [(card_type_2.id, card_type_2.fact_views[0].id), (card_type_2.id, card_type_2.fact_views[1].id)]
        )
        c.active_tag__ids = set([self.database().get_or_create_tag_with_name("default3")._id])
        c.forbidden_tags__ids = set()
        self.database().set_current_activity_criterion(c)
        assert self.database().active_count() == 0