class TestEmailAnalyzer(unittest.TestCase): def setUp(self): self.analyzer = EmailAnalyzer() self.subject_true = " no more outdated software ! upgrade !" self.body_true = "we get you the best deal ! skip the retail box and save !\namazing special # 1 :\nadobe - photoshop 7 premiere 7 illustrator 10 = only $ 120\namazing special # 2 :\nwindows xp professional + microsoft office xp professional = only $ 80\namazing special # 3 :\nadobe photoshop cs + adobe illustrator cs + adobe indesign cs\namazing special # 4 :\n" self.clean_subject_true = [ 'more', 'oudat', 'software', 'upgrade' ] # données pour mocker "return_value" du "clean_text" self.clean_body_true = [ 'get', 'best', 'deal', 'skip', 'retail', 'box', 'sav', 'amaz', 'special', 'adobe', 'photoshop', 'premiere', 'illustrator', 'only', 'windows', 'xp', 'professional', 'microsoft', 'office', 'cs', 'indesign' ] # données pour mocker "return_value" du "clean_text" self.subject_false = "re :" self.body_false = "we are using it for other things . mary joyce and robert have discussed with mcmahon and bowen .\n- - - - - original message - - - - -\nfrom : kitchen louise\nsent : monday december 10 2001 8 : 26 am\nto : oxley david\nsubject :\nwhat happens to the money in wachovia ?\nlouise kitchen\nchief operating \n" self.clean_subject_false = [ 're' ] # données pour mocker "return_value" du "clean_text" self.clean_body_false = [ 'us', 'other', 'thing', 'mary', 'joyce', 'robert', 'discuss', 'mcmahon', 'bowen', 'original', 'message', 'kitchen', 'louise', 'sent', 'monday', "december", 'oxley', 'david', 'subject', 'happen', 'money', 'wachovia' ] self.spam_ham_body_prob_true = ( 1, (1 / 6), ) # données pour mocker "return_value" du "spam_ham_body_prob" self.subject_spam_ham_prob_true = ( (2 / 3), (1 / 6), ) # données pour mocker "return_value" du "subject_spam_ham_prob" self.spam_ham_body_prob_false = ( (1 / 4), (2 / 6), ) # données pour mocker "return_value" du "spam_ham_body_prob" self.subject_spam_ham_prob_false = ( 0, (1 / 2), ) # données pour mocker "return_value" du "subject_spam_ham_prob" self.vocab = ( { "p_sub_spam": { "upgrade": 1 / 3, "software": 1 / 3 }, "p_sub_ham": { "re": 1 / 2, "annoucement": 1 / 6, "more": 1 / 6 }, "p_body_spam": { "best": 1 / 4, "deal": 1 / 4, "skip": 1 / 4, "special": 1 / 4, "money": 1 / 4 }, "p_body_ham": { "today": 1 / 6, "professional": 1 / 6, "meet": 1 / 6, "discuss": 1 / 6, "sent": 1 / 6 } } ) # vocabulaire avec les valeurs de la probabilité pour mocker "return_value" du "load_dict" # valeurs de la probabilité attendus : (0.5925*1/(256*pow(6,17))), (0.4075*1/pow(6,21)) self.spam_ham_body_prob_expected = (1.3673419333309543e-16, 1.8575963755415577e-17) # valeurs de la probabilité attendus : (0.5925*1/81, 0.4075*1/6*1/4*1/4*1/4) self.subject_spam_ham_prob_expected = (0.007314814814814815, 0.0010611979166666665) def tearDown(self): pass @patch("email_analyzer.EmailAnalyzer.clean_text") @patch("email_analyzer.EmailAnalyzer.spam_ham_body_prob") @patch("email_analyzer.EmailAnalyzer.spam_ham_subject_prob") def test_is_spam_Returns_True_if_spam_prob_is_higher( self, mock_subject_spam_ham_prob, mock_spam_ham_body_prob, mock_clean_text): mock_subject_spam_ham_prob.return_value = self.subject_spam_ham_prob_true mock_spam_ham_body_prob.return_value = self.spam_ham_body_prob_true return_val = self.analyzer.is_spam(self.subject_true, self.body_true) self.assertTrue(return_val) """ Il faut mocker les fonctions "spam_ham_body_prob" et "subject_spam_ham_prob". La sortie de la fonction doit être True si probabilité spam > probabilité ham (ces probabilites devron etre calcule selon l'enonce dans le TP1 ) """ @patch("email_analyzer.EmailAnalyzer.clean_text") @patch("email_analyzer.EmailAnalyzer.spam_ham_body_prob") @patch("email_analyzer.EmailAnalyzer.spam_ham_subject_prob") def test_is_spam_Returns_False_if_spam_prob_is_lower( self, mock_subject_spam_ham_prob, mock_spam_ham_body_prob, mock_clean_text): mock_subject_spam_ham_prob.return_value = self.subject_spam_ham_prob_false mock_spam_ham_body_prob.return_value = self.spam_ham_body_prob_false return_val = self.analyzer.is_spam(self.subject_false, self.body_false) self.assertFalse(return_val) """ Il faut mocker les fonctions "spam_ham_body_prob" et "subject_spam_ham_prob". La sortie de la fonction doit être False si probabilité spam probabilité ham (ces probabilites devron etre calcule selon l'enonce dans le TP1 ) """ @patch("email_analyzer.EmailAnalyzer.load_dict") def test_spam_ham_body_prob_Returns_expected_probability( self, mock_load_dict): mock_load_dict.return_value = self.vocab self.assertEqual( self.analyzer.spam_ham_body_prob(self.clean_body_true), self.spam_ham_body_prob_expected) """ Il faut mocker la fonction "load_dict" Il faut vérifier que probabilité est calculée correctement donné le "body" à l'entrée (ces probabilites devron etre calcule selon l'enonce dans le TP1 ) """ @patch("email_analyzer.EmailAnalyzer.load_dict") def test_subject_spam_ham_prob_Returns_expected_probability( self, mock_load_dict): mock_load_dict.return_value = self.vocab self.assertEqual( self.analyzer.spam_ham_subject_prob(self.clean_subject_true), self.subject_spam_ham_prob_expected) """
class TestEmailAnalyzer(unittest.TestCase): def setUp(self): self.subject = "dummySubject" self.body = "dummyBody" self.analyzer = EmailAnalyzer() self.clean_subject = ["best", "quick", "netco"] # données pour mocker "return_value" du "clean_text" self.clean_body = ["prescription", "drug", "overview", "operations"] # données pour mocker "return_value" du "clean_text" self.spam_ham_body_prob_true = ( 0, 0, ) # données pour mocker "return_value" du "spam_ham_body_prob" self.subject_spam_ham_prob_true = ( 0, 0, ) # données pour mocker "return_value" du "subject_spam_ham_prob" self.spam_ham_body_prob_false = ( 0, 0, ) # données pour mocker "return_value" du "spam_ham_body_prob" self.subject_spam_ham_prob_false = ( 0, 0, ) # données pour mocker "return_value" du "subject_spam_ham_prob" self.vocab = ( { "spam_sub": { "best": 1 / 4, "online": 1 / 4, "medicine": 1 / 4, "here": 1 / 4, }, "ham_sub": { "netco": 1 / 3, "due": 1 / 3, "diligence": 1 / 3 }, "spam_body": { "prescription": 1 / 5, "drug": 1 / 5, "simple": 1 / 5, "quick": 1 / 5, "affordable": 1 / 5 }, "ham_body": { "big": 1 / 6, "pig": 1 / 6, "met": 1 / 6, "today": 1 / 6, "overview": 1 / 6, "operations": 1 / 6 } } ) # vocabulaire avec les valeurs de la probabilité pour mocker "return_value" du "load_dict" self.spam_ham_body_prob_expected = 0, 0 # valeurs de la probabilité attendus self.subject_spam_ham_prob_expected = 0, 0 # valeurs de la probabilité attendus def tearDown(self): pass ### Tests pour l'Active clause coverage def test_is_spam_function_one_returns_true_acc_test_one(self): return_val = EmailAnalyzer.is_spam_function_one(True, 35, 65, 60) self.assertTrue(return_val) def test_is_spam_function_one_returns_false_acc_test_two(self): return_val = EmailAnalyzer.is_spam_function_one(True, 35, 65, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_true_acc_test_three(self): return_val = EmailAnalyzer.is_spam_function_one(False, 20, 50, 50) self.assertTrue(return_val) def test_is_spam_function_one_returns_false_acc_test_four(self): return_val = EmailAnalyzer.is_spam_function_one(False, 35, 50, 50) self.assertFalse(return_val) def test_is_spam_function_one_returns_true_acc_test_five(self): return_val = EmailAnalyzer.is_spam_function_one(True, 20, 50, 80) self.assertTrue(return_val) def test_is_spam_function_one_returns_false_acc_test_six(self): return_val = EmailAnalyzer.is_spam_function_one(True, 20, 70, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_true_acc_test_seven(self): return_val = EmailAnalyzer.is_spam_function_one(False, 20, 70, 50) self.assertTrue(return_val) def test_is_spam_function_one_returns_false_acc_test_eight(self): return_val = EmailAnalyzer.is_spam_function_one(False, 20, 70, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_false_acc_test_nine(self): return_val = EmailAnalyzer.is_spam_function_one(False, 20, 76, 50) self.assertFalse(return_val) # Tests pour l'Inactive Clause Coverage # P est clause majeure: def test_is_spam_function_one_returns_false_icc_test_one(self): return_val = EmailAnalyzer.is_spam_function_one(True, 35, 65, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_false_icc_test_two(self): return_val = EmailAnalyzer.is_spam_function_one(False, 35, 65, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_true_icc_test_three(self): return_val = EmailAnalyzer.is_spam_function_one(False, 15, 65, 50) self.assertTrue(return_val) def test_is_spam_function_one_returns_false_icc_test_four(self): return_val = EmailAnalyzer.is_spam_function_one(True, 15, 65, 50) self.assertTrue(return_val) # H est clause majeure def test_is_spam_function_one_returns_true_icc_test_five(self): return_val = EmailAnalyzer.is_spam_function_one(True, 20, 65, 60) self.assertTrue(return_val) def test_is_spam_function_one_returns_true_icc_test_six(self): return_val = EmailAnalyzer.is_spam_function_one(True, 15, 65, 60) self.assertTrue(return_val) def test_is_spam_function_one_returns_false_icc_test_seven(self): return_val = EmailAnalyzer.is_spam_function_one(False, 40, 65, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_false_icc_test_eight(self): return_val = EmailAnalyzer.is_spam_function_one(False, 15, 65, 80) self.assertFalse(return_val) # T1 clause majeure def test_is_spam_function_one_returns_false_icc_test_nine(self): return_val = EmailAnalyzer.is_spam_function_one(False, 35, 65, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_false_icc_test_ten(self): return_val = EmailAnalyzer.is_spam_function_one(False, 35, 50, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_true_icc_test_eleven(self): return_val = EmailAnalyzer.is_spam_function_one(False, 20, 50, 60) self.assertTrue(return_val) def test_is_spam_function_one_returns_false_icc_test_twelve(self): return_val = EmailAnalyzer.is_spam_function_one(False, 20, 65, 60) self.assertTrue(return_val) # T2 clause majeure def test_is_spam_function_one_returns_false_icc_test_thirteen(self): return_val = EmailAnalyzer.is_spam_function_one(False, 35, 65, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_false_icc_test_fourteen(self): return_val = EmailAnalyzer.is_spam_function_one(False, 35, 65, 50) self.assertFalse(return_val) def test_is_spam_function_one_returns_true_icc_test_fifteen(self): return_val = EmailAnalyzer.is_spam_function_one(True, 20, 50, 80) self.assertTrue(return_val) def test_is_spam_function_one_returns_false_icc_test_sixteen(self): return_val = EmailAnalyzer.is_spam_function_one(True, 20, 50, 50) self.assertTrue(return_val) # T3 clause majeure def test_is_spam_function_one_returns_false_icc_test_seventeen(self): return_val = EmailAnalyzer.is_spam_function_one(False, 35, 65, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_false_icc_test_eighteen(self): return_val = EmailAnalyzer.is_spam_function_one(False, 35, 80, 80) self.assertFalse(return_val) def test_is_spam_function_one_returns_true_icc_test_nineteen(self): return_val = EmailAnalyzer.is_spam_function_one(True, 35, 65, 60) self.assertTrue(return_val) def test_is_spam_function_one_returns_false_icc_test_twenty(self): return_val = EmailAnalyzer.is_spam_function_one(True, 35, 80, 60) self.assertTrue(return_val) # Critère IC def test_is_spam_function_two_returns_false_ic_test_one(self): return_val = EmailAnalyzer.is_spam_function_two(False, 80, 80) self.assertFalse(return_val) def test_is_spam_function_two_returns_true_ic_test_two(self): return_val = EmailAnalyzer.is_spam_function_two(True, 20, 65) self.assertTrue(return_val) # Critère PIC def test_is_spam_function_two_returns_false_pic_test_one(self): return_val = EmailAnalyzer.is_spam_function_two(False, 80, 65) self.assertFalse(return_val) def test_is_spam_function_two_returns_false_pic_test_two(self): return_val = EmailAnalyzer.is_spam_function_two(False, 20, 80) self.assertFalse(return_val) def test_is_spam_function_two_returns_true_pic_test_three(self): return_val = EmailAnalyzer.is_spam_function_two(True, 80, 65) self.assertTrue(return_val) def test_is_spam_function_two_returns_true_pic_test_four(self): return_val = EmailAnalyzer.is_spam_function_two(False, 20, 50) self.assertTrue(return_val) # Critère VNS def test_is_spam_function_two_returns_true_vns_test_one(self): return_val = EmailAnalyzer.is_spam_function_two(True, 80, 80) self.assertTrue(return_val) def test_is_spam_function_two_returns_true_vns_test_two(self): return_val = EmailAnalyzer.is_spam_function_two(True, 80, 65) self.assertTrue(return_val) def test_is_spam_function_two_returns_true_vns_test_three(self): return_val = EmailAnalyzer.is_spam_function_two(True, 20, 80) self.assertTrue(return_val) def test_is_spam_function_two_returns_true_vns_test_four(self): return_val = EmailAnalyzer.is_spam_function_two(False, 20, 65) self.assertTrue(return_val) def test_is_spam_function_two_returns_false_vns_test_five(self): return_val = EmailAnalyzer.is_spam_function_two(False, 20, 80) self.assertFalse(return_val) def test_is_spam_function_two_returns_false_vns_test_six(self): return_val = EmailAnalyzer.is_spam_function_two(False, 80, 60) self.assertFalse(return_val) def test_is_spam_function_two_returns_false_vns_test_seven(self): return_val = EmailAnalyzer.is_spam_function_two(False, 80, 80) self.assertFalse(return_val) @patch("email_analyzer.EmailAnalyzer.subject_spam_ham_prob") @patch("email_analyzer.EmailAnalyzer.spam_ham_body_prob") def test_is_spam_Returns_True_if_spam_prob_is_higher( self, mock_subject_spam_ham_prob, mock_spam_ham_body_prob ): """ Il faut mocker les fonctions "spam_ham_body_prob" et "subject_spam_ham_prob". La sortie de la fonction doit être True si probabilité spam > probabilité ham (ces probabilites devron etre calcule selon l'enonce dans le TP1 ) """ mock_subject_spam_ham_prob.return_value = (10, 0) mock_spam_ham_body_prob.return_value = (10, 0) is_spam_return_val = self.analyzer.is_spam("dummySubject", "dummyBody") self.assertTrue(is_spam_return_val) @patch("email_analyzer.EmailAnalyzer.spam_ham_body_prob") @patch("email_analyzer.EmailAnalyzer.subject_spam_ham_prob") def test_is_spam_Returns_False_if_spam_prob_is_lower( self, mock_subject_spam_ham_prob, mock_spam_ham_body_prob ): """ Il faut mocker les fonctions "spam_ham_body_prob" et "subject_spam_ham_prob". La sortie de la fonction doit être False si probabilité spam probabilité ham (ces probabilites devron etre calcule selon l'enonce dans le TP1 ) """ mock_subject_spam_ham_prob.return_value = (0, 10) mock_spam_ham_body_prob.return_value = (0, 10) is_spam_return_val = self.analyzer.is_spam("dummySubject", "dummyBody") self.assertFalse(is_spam_return_val) @patch("email_analyzer.EmailAnalyzer.clean_text") @patch("email_analyzer.EmailAnalyzer.calculate_ham_divided_by_email") @patch("email_analyzer.EmailAnalyzer.calculate_spam_divided_by_email") @patch("email_analyzer.EmailAnalyzer.load_dict") def test_spam_ham_body_prob_Returns_expected_probability(self, mock_load_dict, mock_calculate_spam_divided_by_email, mock_calculate_ham_divided_by_email, mock_clean_text): """ Il faut mocker la fonction "load_dict" Il faut vérifier que probabilité est calculée correctement donné le "body" à l'entrée (ces probabilites devront etre calcule selon l'enonce dans le TP1 ) """ mock_load_dict.return_value = self.vocab mock_calculate_ham_divided_by_email.return_value = 1 / 2 mock_calculate_spam_divided_by_email.return_value = 1 / 2 mock_clean_text.return_value = self.clean_body expected_return_value = ((0.5 * 0.2 * 0.2), (1 / 2 * 1 / 6 * 1 / 6)) self.assertEqual(self.analyzer.spam_ham_body_prob(self.body), expected_return_value) @patch("email_analyzer.EmailAnalyzer.clean_text") @patch("email_analyzer.EmailAnalyzer.calculate_ham_divided_by_email") @patch("email_analyzer.EmailAnalyzer.calculate_spam_divided_by_email") @patch("email_analyzer.EmailAnalyzer.load_dict") def test_subject_spam_ham_prob_Returns_expected_probability(self, mock_load_dict, mock_calculate_spam_divided_by_email, mock_calculate_ham_divided_by_email, mock_clean_text): """ Il faut mocker la fonction "load_dict" il faut vérifier que probabilité est calculée correctement donné le "sujet" a l'entrée (ces probabilites devron etre calcule selon l'enonce dans le TP1 ) """ mock_load_dict.return_value = self.vocab mock_calculate_ham_divided_by_email.return_value = 1 / 2 mock_calculate_spam_divided_by_email.return_value = 1 / 2 mock_clean_text.return_value = self.clean_subject expected_return_value = ((0.5 * 0.25), (0.5*1/3)) self.assertEqual(self.analyzer.subject_spam_ham_prob(self.subject), expected_return_value)
class TestEmailAnalyzer(unittest.TestCase): def setUp(self): self.subject = "dummySubject" self.body = "dummyBody" self.analyzer = EmailAnalyzer() self.clean_subject = [ "best", "quick", "netco" ] # données pour mocker "return_value" du "clean_text" self.clean_body = [ "prescription", "drug", "overview", "operations" ] # données pour mocker "return_value" du "clean_text" self.spam_ham_body_prob_true = ( 0, 0, ) # données pour mocker "return_value" du "spam_ham_body_prob" self.subject_spam_ham_prob_true = ( 0, 0, ) # données pour mocker "return_value" du "subject_spam_ham_prob" self.spam_ham_body_prob_false = ( 0, 0, ) # données pour mocker "return_value" du "spam_ham_body_prob" self.subject_spam_ham_prob_false = ( 0, 0, ) # données pour mocker "return_value" du "subject_spam_ham_prob" self.vocab = ( { "spam_sub": { "best": 1 / 4, "online": 1 / 4, "medicine": 1 / 4, "here": 1 / 4, }, "ham_sub": { "netco": 1 / 3, "due": 1 / 3, "diligence": 1 / 3 }, "spam_body": { "prescription": 1 / 5, "drug": 1 / 5, "simple": 1 / 5, "quick": 1 / 5, "affordable": 1 / 5 }, "ham_body": { "big": 1 / 6, "pig": 1 / 6, "met": 1 / 6, "today": 1 / 6, "overview": 1 / 6, "operations": 1 / 6 } } ) # vocabulaire avec les valeurs de la probabilité pour mocker "return_value" du "load_dict" self.spam_ham_body_prob_expected = 0, 0 # valeurs de la probabilité attendus self.subject_spam_ham_prob_expected = 0, 0 # valeurs de la probabilité attendus def tearDown(self): pass @patch("email_analyzer.EmailAnalyzer.subject_spam_ham_prob") @patch("email_analyzer.EmailAnalyzer.spam_ham_body_prob") def test_is_spam_Returns_True_if_spam_prob_is_higher( self, mock_subject_spam_ham_prob, mock_spam_ham_body_prob): """ Il faut mocker les fonctions "spam_ham_body_prob" et "subject_spam_ham_prob". La sortie de la fonction doit être True si probabilité spam > probabilité ham (ces probabilites devron etre calcule selon l'enonce dans le TP1 ) """ mock_subject_spam_ham_prob.return_value = (10, 0) mock_spam_ham_body_prob.return_value = (10, 0) is_spam_return_val = self.analyzer.is_spam("dummySubject", "dummyBody") self.assertTrue(is_spam_return_val) @patch("email_analyzer.EmailAnalyzer.spam_ham_body_prob") @patch("email_analyzer.EmailAnalyzer.subject_spam_ham_prob") def test_is_spam_Returns_False_if_spam_prob_is_lower( self, mock_subject_spam_ham_prob, mock_spam_ham_body_prob): """ Il faut mocker les fonctions "spam_ham_body_prob" et "subject_spam_ham_prob". La sortie de la fonction doit être False si probabilité spam probabilité ham (ces probabilites devron etre calcule selon l'enonce dans le TP1 ) """ mock_subject_spam_ham_prob.return_value = (0, 10) mock_spam_ham_body_prob.return_value = (0, 10) is_spam_return_val = self.analyzer.is_spam("dummySubject", "dummyBody") self.assertFalse(is_spam_return_val) @patch("email_analyzer.EmailAnalyzer.clean_text") @patch("email_analyzer.EmailAnalyzer.calculate_ham_divided_by_email") @patch("email_analyzer.EmailAnalyzer.calculate_spam_divided_by_email") @patch("email_analyzer.EmailAnalyzer.load_dict") def test_spam_ham_body_prob_Returns_expected_probability( self, mock_load_dict, mock_calculate_spam_divided_by_email, mock_calculate_ham_divided_by_email, mock_clean_text): """ Il faut mocker la fonction "load_dict" Il faut vérifier que probabilité est calculée correctement donné le "body" à l'entrée (ces probabilites devront etre calcule selon l'enonce dans le TP1 ) """ mock_load_dict.return_value = self.vocab mock_calculate_ham_divided_by_email.return_value = 1 / 2 mock_calculate_spam_divided_by_email.return_value = 1 / 2 mock_clean_text.return_value = self.clean_body expected_return_value = ((0.5 * 0.2 * 0.2), (1 / 2 * 1 / 6 * 1 / 6)) self.assertEqual(self.analyzer.spam_ham_body_prob(self.body), expected_return_value) @patch("email_analyzer.EmailAnalyzer.clean_text") @patch("email_analyzer.EmailAnalyzer.calculate_ham_divided_by_email") @patch("email_analyzer.EmailAnalyzer.calculate_spam_divided_by_email") @patch("email_analyzer.EmailAnalyzer.load_dict") def test_subject_spam_ham_prob_Returns_expected_probability( self, mock_load_dict, mock_calculate_spam_divided_by_email, mock_calculate_ham_divided_by_email, mock_clean_text): """ Il faut mocker la fonction "load_dict" il faut vérifier que probabilité est calculée correctement donné le "sujet" a l'entrée (ces probabilites devron etre calcule selon l'enonce dans le TP1 ) """ mock_load_dict.return_value = self.vocab mock_calculate_ham_divided_by_email.return_value = 1 / 2 mock_calculate_spam_divided_by_email.return_value = 1 / 2 mock_clean_text.return_value = self.clean_subject expected_return_value = ((0.5 * 0.25), (0.5 * 1 / 3)) self.assertEqual(self.analyzer.subject_spam_ham_prob(self.subject), expected_return_value)