← Back to branch summary

~kevang/mnemosyne-proj/grade-shortcuts-improvements

« back to all changes in this revision

Viewing changes to mnemosyne/tests/test_logging.py

  • Committer: pbienst
  • Date: 2006-02-09 16:13:13 UTC
  • Revision ID: svn-v3-trunk0:e5e6b78b-db40-0410-9517-b98c64f8d2c1:trunk:2
Initial revision

Show diffs side-by-side

added added

removed removed

Lines of Context:
mnemosyne/tests/test_logging.py
1
 
#
2
 
# test_logging.py <Peter.Bienstman@UGent.be>
3
 
#
4
 
 
5
 
import os
6
 
 
7
 
from mnemosyne_test import MnemosyneTest
8
 
from mnemosyne.libmnemosyne import Mnemosyne
9
 
from openSM2sync.log_entry import EventTypes
10
 
from mnemosyne.libmnemosyne.ui_components.main_widget import MainWidget
11
 
 
12
 
 
13
 
class MyMainWidget(MainWidget):
14
 
 
15
 
    def show_question(self, question, b, c, d):
16
 
        if question == "Delete this card?":
17
 
            return 1 # Yes
18
 
        else:
19
 
            raise NotImplementedError
20
 
 
21
 
 
22
 
class TestLogging(MnemosyneTest):
23
 
 
24
 
    def restart(self):
25
 
        self.mnemosyne = Mnemosyne(upload_science_logs=False, interested_in_old_reps=True,
26
 
            asynchronous_database=True)
27
 
        self.mnemosyne.components.insert(0,
28
 
           ("mnemosyne.libmnemosyne.translators.gettext_translator", "GetTextTranslator"))
29
 
        self.mnemosyne.components.append(\
30
 
            ("test_logging", "MyMainWidget"))
31
 
        self.mnemosyne.components.append(\
32
 
            ("mnemosyne_test", "TestReviewWidget"))
33
 
        self.mnemosyne.initialise(os.path.abspath("dot_test"), automatic_upgrades=False)
34
 
        self.mnemosyne.start_review()
35
 
 
36
 
    def test_logging(self):
37
 
        card_type = self.card_type_with_id("1")
38
 
        fact_data = {"f": "1", "b": "b"}
39
 
        card = self.controller().create_new_cards(fact_data, card_type,
40
 
                     grade=-1, tag_names=["default"])[0]
41
 
        card_id_1 = card.id
42
 
        self.review_controller().show_new_question()
43
 
        self.review_controller().grade_answer(0)
44
 
        self.review_controller().show_new_question()
45
 
        self.review_controller().grade_answer(1)
46
 
        self.review_controller().grade_answer(4)
47
 
 
48
 
        self.mnemosyne.finalise()
49
 
        self.restart()
50
 
        card_type = self.card_type_with_id("1")
51
 
        fact_data = {"f": "2", "b": "b"}
52
 
        card = self.controller().create_new_cards(fact_data, card_type,
53
 
                     grade=-1, tag_names=["default"])[0]
54
 
        self.review_controller().show_new_question()
55
 
        self.controller().delete_current_card()
56
 
 
57
 
        self.log().dump_to_science_log()
58
 
 
59
 
        sql_res = self.database().con.execute(\
60
 
            "select * from log where _id=1").fetchone()
61
 
        assert sql_res[1] == EventTypes.STARTED_PROGRAM
62
 
 
63
 
        sql_res = self.database().con.execute(\
64
 
            "select * from log where _id=2").fetchone()
65
 
        assert sql_res[1] == EventTypes.STARTED_SCHEDULER
66
 
 
67
 
        sql_res = self.database().con.execute(\
68
 
            "select * from log where _id=3").fetchone()
69
 
        assert sql_res[1] == EventTypes.LOADED_DATABASE
70
 
        assert sql_res[6] == 0
71
 
        assert sql_res[7] == 0
72
 
        assert sql_res[8] == 0
73
 
 
74
 
        sql_res = self.database().con.execute(\
75
 
            "select * from log where _id=11").fetchone()
76
 
        assert sql_res[1] == EventTypes.ADDED_TAG
77
 
        assert sql_res[3] is not None
78
 
 
79
 
        sql_res = self.database().con.execute(\
80
 
            "select * from log where _id=12").fetchone()
81
 
        assert sql_res[1] == EventTypes.EDITED_CRITERION
82
 
        assert sql_res[3] is not None
83
 
 
84
 
        sql_res = self.database().con.execute(\
85
 
            "select * from log where _id=13").fetchone()
86
 
        assert sql_res[1] == EventTypes.ADDED_FACT
87
 
        assert sql_res[3] is not None
88
 
 
89
 
        sql_res = self.database().con.execute(\
90
 
            "select * from log where _id=14").fetchone()
91
 
        assert sql_res[1] == EventTypes.ADDED_CARD
92
 
        assert sql_res[3] is not None
93
 
 
94
 
        sql_res = self.database().con.execute(\
95
 
            "select * from log where _id=15").fetchone()
96
 
        assert sql_res[1] == EventTypes.REPETITION
97
 
        assert sql_res[6] == 1
98
 
        assert sql_res[7] == 0
99
 
        assert sql_res[11] == 0
100
 
        assert sql_res[12] == 0
101
 
        assert sql_res[14] - sql_res[2] == 0
102
 
        assert sql_res[13] == 0
103
 
        assert sql_res[3] is not None
104
 
 
105
 
        sql_res = self.database().con.execute(\
106
 
            "select * from log where _id=16").fetchone()
107
 
        assert sql_res[1] == EventTypes.REPETITION
108
 
        assert sql_res[6] == 2
109
 
        assert sql_res[7] == 0
110
 
        assert sql_res[11] == 0
111
 
        assert sql_res[12] <= 10 # Depends on CPU load.
112
 
        assert sql_res[14] - sql_res[2] == 0
113
 
        assert sql_res[13] == 0
114
 
 
115
 
        sql_res = self.database().con.execute(\
116
 
            "select * from log where _id=17").fetchone()
117
 
        assert sql_res[1] == EventTypes.REPETITION
118
 
        assert sql_res[6] == 3
119
 
        assert sql_res[7] == 0
120
 
        assert sql_res[11] == 0
121
 
        assert sql_res[12] <= 10 # Depends on CPU load.
122
 
        new_interval = sql_res[14] - sql_res[2]
123
 
        assert new_interval > 0
124
 
        assert sql_res[13] == 0
125
 
 
126
 
        sql_res = self.database().con.execute(\
127
 
            "select * from log where _id=18").fetchone()
128
 
        assert sql_res[1] == EventTypes.SAVED_DATABASE
129
 
        assert sql_res[6] == 0
130
 
        assert sql_res[7] == 0
131
 
        assert sql_res[8] == 1
132
 
 
133
 
        sql_res = self.database().con.execute(\
134
 
            "select * from log where _id=19").fetchone()
135
 
        assert sql_res[1] == EventTypes.STOPPED_PROGRAM
136
 
 
137
 
        sql_res = self.database().con.execute(\
138
 
            "select * from log where _id=20").fetchone()
139
 
        assert sql_res[1] == EventTypes.STARTED_PROGRAM
140
 
 
141
 
        sql_res = self.database().con.execute(\
142
 
            "select * from log where _id=21").fetchone()
143
 
        assert sql_res[1] == EventTypes.STARTED_SCHEDULER
144
 
 
145
 
        sql_res = self.database().con.execute(\
146
 
            "select * from log where _id=22").fetchone()
147
 
        assert sql_res[1] == EventTypes.LOADED_DATABASE
148
 
        assert sql_res[6] == 0
149
 
        assert sql_res[7] == 0
150
 
        assert sql_res[8] == 1
151
 
 
152
 
        sql_res = self.database().con.execute(\
153
 
            "select * from log where _id=30").fetchone()
154
 
        assert sql_res[1] == EventTypes.ADDED_FACT
155
 
        assert sql_res[3] is not None
156
 
 
157
 
        sql_res = self.database().con.execute(\
158
 
            "select * from log where _id=31").fetchone()
159
 
        assert sql_res[1] == EventTypes.ADDED_CARD
160
 
 
161
 
        sql_res = self.database().con.execute(\
162
 
            "select * from log where _id=32").fetchone()
163
 
        assert sql_res[1] == EventTypes.DELETED_CARD
164
 
        assert sql_res[3] is not None
165
 
 
166
 
        sql_res = self.database().con.execute(\
167
 
            "select * from log where _id=33").fetchone()
168
 
        assert sql_res[1] == EventTypes.DELETED_FACT
169
 
        assert sql_res[3] is not None
170
 
 
171
 
        self.config()["upload_science_logs"] = True
172
 
        self.database().dump_to_science_log()
173
 
 
174
 
        logfile = os.path.join(os.path.abspath("dot_test"), "log.txt")
175
 
        found = False
176
 
        for line in file(logfile):
177
 
            if "R " + card_id_1 + " 4" in line:
178
 
                found = True
179
 
                assert str(new_interval) + " 0 | 0.0" in line
180
 
        assert found == True
181
 
 
182
 
    def test_unique_index(self):
183
 
        fact_data = {"f": "question",
184
 
                     "b": "answer"}
185
 
        card_type_2 = self.card_type_with_id("2")
186
 
        card_1, card_2 = self.controller().create_new_cards(fact_data, card_type_2,
187
 
                                              grade=-1, tag_names=["default"])
188
 
        log_index = self.database().con.execute(\
189
 
            """select _id from log order by _id desc limit 1""").fetchone()[0]
190
 
        # Note: we need to keep the last log entry intact, otherwise indexes
191
 
        # start again at 1 and mess up the sync.
192
 
        self.database().con.execute("""delete from log where _id <?""", (log_index,))
193
 
        self.database().con.execute("""vacuum""")
194
 
        fact_data = {"f": "question2",
195
 
                     "b": "answer2"}
196
 
        card_type_2 = self.card_type_with_id("1")
197
 
        card_1  = self.controller().create_new_cards(fact_data, card_type_2,
198
 
                                              grade=-1, tag_names=["default"])
199
 
        assert self.database().con.execute(\
200
 
            """select _id from log order by _id limit 1""").fetchone()[0] \
201
 
            == log_index
202
 
 
203
 
    def test_recover_user_id(self):
204
 
        assert self.config()["user_id"] is not None
205
 
        MnemosyneTest.teardown(self)
206
 
 
207
 
        file(os.path.join(os.getcwd(), "dot_test", "history", "userid_001.bz2"), "w")
208
 
        os.remove(os.path.join(os.getcwd(), "dot_test", "config.db"))
209
 
 
210
 
        self.mnemosyne = Mnemosyne(upload_science_logs=False, interested_in_old_reps=True,
211
 
            asynchronous_database=True)
212
 
        self.mnemosyne.components.insert(0,
213
 
           ("mnemosyne.libmnemosyne.translators.gettext_translator", "GetTextTranslator"))
214
 
        self.mnemosyne.components.append(\
215
 
            ("test_logging", "MyMainWidget"))
216
 
        self.mnemosyne.components.append(\
217
 
            ("mnemosyne_test", "TestReviewWidget"))
218
 
        self.mnemosyne.initialise(os.path.abspath("dot_test"), automatic_upgrades=False)
219
 
 
220
 
        assert self.config()["user_id"] == "userid"
221
 
 
222
 
    def test_recover_user_id_2(self):
223
 
        assert self.config()["user_id"] is not None
224
 
        MnemosyneTest.teardown(self)
225
 
 
226
 
        file(os.path.join(os.getcwd(), "dot_test", "history", "userid_machine_001.bz2"), "w")
227
 
        os.remove(os.path.join(os.getcwd(), "dot_test", "config.db"))
228
 
 
229
 
        self.mnemosyne = Mnemosyne(upload_science_logs=False, interested_in_old_reps=True,
230
 
            asynchronous_database=True)
231
 
        self.mnemosyne.components.insert(0,
232
 
           ("mnemosyne.libmnemosyne.translators.gettext_translator", "GetTextTranslator"))
233
 
        self.mnemosyne.components.append(\
234
 
            ("test_logging", "MyMainWidget"))
235
 
        self.mnemosyne.components.append(\
236
 
            ("mnemosyne_test", "TestReviewWidget"))
237
 
        self.mnemosyne.initialise(os.path.abspath("dot_test"), automatic_upgrades=False)
238
 
 
239
 
        assert self.config()["user_id"] == "userid"
240
 
 
241
 
    def test_log_index_of_last_upload_1(self):
242
 
        assert self.log().log_index_of_last_upload() == 0
243
 
 
244
 
    def test_log_index_of_last_upload_2(self):
245
 
        machine_id = self.config().machine_id()
246
 
        for filename in ["user_001.bz2", "user_%s_2.bz2" % machine_id]:
247
 
            file(os.path.join(os.getcwd(), "dot_test", "history", filename), "w")
248
 
        assert self.log().log_index_of_last_upload() == 2
249
 
 
250
 
    def test_log_index_of_last_upload_3(self):
251
 
        machine_id = self.config().machine_id()
252
 
        for filename in ["user_001.bz2"]:
253
 
            file(os.path.join(os.getcwd(), "dot_test", "history", filename), "w")
254
 
        assert self.log().log_index_of_last_upload() == 1
255
 
 
256
 
    def test_log_index_of_last_upload_4(self):
257
 
        machine_id = self.config().machine_id()
258
 
        for filename in ["user_005.bz2"]:
259
 
            file(os.path.join(os.getcwd(), "dot_test", "history", filename), "w")
260
 
        assert self.log().log_index_of_last_upload() == 5
261
 
 
262
 
    def test_log_index_of_last_upload_5(self):
263
 
        machine_id = self.config().machine_id()
264
 
        for filename in ["user_othermachine_005.bz2"]:
265
 
            file(os.path.join(os.getcwd(), "dot_test", "history", filename), "w")
266
 
        assert self.log().log_index_of_last_upload() == 0
267
 
 
268
 
    def test_log_index_of_last_upload_6(self):
269
 
        machine_id = self.config().machine_id()
270
 
        for filename in ["user_othermachine_005.bz2", "user_%s_2.bz2" % machine_id]:
271
 
            file(os.path.join(os.getcwd(), "dot_test", "history", filename), "w")
272
 
        assert self.log().log_index_of_last_upload() == 2
273
 
 
274
 
    def test_log_index_of_last_upload_7(self):
275
 
        machine_id = self.config().machine_id()
276
 
        for filename in ["user_001.bz2", "user_othermachine_005.bz2", "user_%s_2.bz2" % machine_id]:
277
 
            file(os.path.join(os.getcwd(), "dot_test", "history", filename), "w")
278
 
        assert self.log().log_index_of_last_upload() == 2
279
 
 
280
 
    def test_log_upload(self):
281
 
        machine_id_file = os.path.join(self.mnemosyne.config().config_dir, "machine.id")
282
 
        f = file(machine_id_file, "w")
283
 
        print >> f, "TESTMACHINE"
284
 
        f.close()
285
 
        self.config().change_user_id("UPLOADTEST")
286
 
        self.config()["max_log_size_before_upload"] = 1
287
 
        MnemosyneTest.teardown(self)
288
 
 
289
 
        self.mnemosyne = Mnemosyne(upload_science_logs=True, interested_in_old_reps=True,
290
 
            asynchronous_database=True)
291
 
        self.mnemosyne.components.insert(0,
292
 
           ("mnemosyne.libmnemosyne.translators.gettext_translator", "GetTextTranslator"))
293
 
        self.mnemosyne.components.append(\
294
 
            ("test_logging", "MyMainWidget"))
295
 
        self.mnemosyne.components.append(\
296
 
            ("mnemosyne_test", "TestReviewWidget"))
297
 
        self.mnemosyne.initialise(os.path.abspath("dot_test"), automatic_upgrades=False)
298
 
        self.mnemosyne.start_review()
299
 
        MnemosyneTest.teardown(self)
300
 
 
301
 
        self.mnemosyne = Mnemosyne(upload_science_logs=True, interested_in_old_reps=True,
302
 
            asynchronous_database=True)
303
 
        self.mnemosyne.components.insert(0,
304
 
           ("mnemosyne.libmnemosyne.translators.gettext_translator", "GetTextTranslator"))
305
 
        self.mnemosyne.components.append(\
306
 
            ("test_logging", "MyMainWidget"))
307
 
        self.mnemosyne.components.append(\
308
 
            ("mnemosyne_test", "TestReviewWidget"))
309
 
        self.mnemosyne.initialise(os.path.abspath("dot_test"), automatic_upgrades=False)
310
 
        self.mnemosyne.start_review()
311
 
        MnemosyneTest.teardown(self)
312
 
 
313
 
        self.mnemosyne = Mnemosyne(upload_science_logs=True, interested_in_old_reps=True,
314
 
            asynchronous_database=True)
315
 
        self.mnemosyne.components.insert(0,
316
 
           ("mnemosyne.libmnemosyne.translators.gettext_translator", "GetTextTranslator"))
317
 
        self.mnemosyne.components.append(\
318
 
            ("test_logging", "MyMainWidget"))
319
 
        self.mnemosyne.components.append(\
320
 
            ("mnemosyne_test", "TestReviewWidget"))
321
 
        self.mnemosyne.initialise(os.path.abspath("dot_test"), automatic_upgrades=False)
322
 
        self.mnemosyne.start_review()
323
 
 
324
 
 
325
 
    def test_log_upload_bad_server(self):
326
 
        # Most reliable way of setting this variable is throug config.py, otherwise
327
 
        # it will stay alive in a dangling imported userconfig.
328
 
        config_py_file = os.path.join(self.mnemosyne.config().config_dir, "config.py")
329
 
        f = file(config_py_file, "w")
330
 
        print >> f, "science_server = \"noserver:80\""
331
 
        f.close()
332
 
 
333
 
        machine_id_file = os.path.join(self.mnemosyne.config().config_dir, "machine.id")
334
 
        f = file(machine_id_file, "w")
335
 
        print >> f, "TESTMACHINE"
336
 
        f.close()
337
 
        self.config().change_user_id("UPLOADTEST")
338
 
        self.config()["max_log_size_before_upload"] = 1
339
 
        MnemosyneTest.teardown(self)
340
 
 
341
 
        self.mnemosyne = Mnemosyne(upload_science_logs=True, interested_in_old_reps=True,
342
 
            asynchronous_database=True)
343
 
        self.mnemosyne.components.insert(0,
344
 
           ("mnemosyne.libmnemosyne.translators.gettext_translator", "GetTextTranslator"))
345
 
        self.mnemosyne.components.append(\
346
 
            ("test_logging", "MyMainWidget"))
347
 
        self.mnemosyne.components.append(\
348
 
            ("mnemosyne_test", "TestReviewWidget"))
349
 
        self.mnemosyne.initialise(os.path.abspath("dot_test"), automatic_upgrades=False)
350
 
        self.mnemosyne.start_review()
351
 
        MnemosyneTest.teardown(self)
352
 
 
353
 
        self.mnemosyne = Mnemosyne(upload_science_logs=True, interested_in_old_reps=True,
354
 
            asynchronous_database=True)
355
 
        self.mnemosyne.components.insert(0,
356
 
           ("mnemosyne.libmnemosyne.translators.gettext_translator", "GetTextTranslator"))
357
 
        self.mnemosyne.components.append(\
358
 
            ("test_logging", "MyMainWidget"))
359
 
        self.mnemosyne.components.append(\
360
 
            ("mnemosyne_test", "TestReviewWidget"))
361
 
        self.mnemosyne.initialise(os.path.abspath("dot_test"), automatic_upgrades=False)
362
 
        self.mnemosyne.start_review()