1  """Test cases for shared.py"""
  2  
  3  import unittest
  4  from pybitmessage.shared import (
  5      isAddressInMyAddressBook,
  6      isAddressInMySubscriptionsList,
  7      checkSensitiveFilePermissions,
  8      reloadBroadcastSendersForWhichImWatching,
  9      fixSensitiveFilePermissions,
 10      MyECSubscriptionCryptorObjects,
 11      stat,
 12      os,
 13  )
 14  
 15  from .samples import sample_address
 16  
 17  try:
 18      # Python 3
 19      from unittest.mock import patch, PropertyMock
 20  except ImportError:
 21      # Python 2
 22      from mock import patch, PropertyMock
 23  
 24  # mock os.stat data for file
 25  PERMISSION_MODE1 = stat.S_IRUSR  # allow Read permission for the file owner.
 26  PERMISSION_MODE2 = (
 27      stat.S_IRWXO
 28  )  # allow read, write, serach & execute permission for other users
 29  INODE = 753
 30  DEV = 1795
 31  NLINK = 1
 32  UID = 1000
 33  GID = 0
 34  SIZE = 1021
 35  ATIME = 1711587560
 36  MTIME = 1709449249
 37  CTIME = 1709449603
 38  
 39  
 40  class TestShared(unittest.TestCase):
 41      """Test class for shared.py"""
 42  
 43      @patch("pybitmessage.shared.sqlQuery")
 44      def test_isaddress_in_myaddressbook(self, mock_sql_query):
 45          """Test if address is in MyAddressbook"""
 46          address = sample_address
 47  
 48          # if address is in MyAddressbook
 49          mock_sql_query.return_value = [address]
 50          return_val = isAddressInMyAddressBook(address)
 51          mock_sql_query.assert_called_once()
 52          self.assertTrue(return_val)
 53  
 54          # if address is not in MyAddressbook
 55          mock_sql_query.return_value = []
 56          return_val = isAddressInMyAddressBook(address)
 57          self.assertFalse(return_val)
 58          self.assertEqual(mock_sql_query.call_count, 2)
 59  
 60      @patch("pybitmessage.shared.sqlQuery")
 61      def test_isaddress_in_mysubscriptionslist(self, mock_sql_query):
 62          """Test if address is in MySubscriptionsList"""
 63  
 64          address = sample_address
 65  
 66          # if address is in MySubscriptionsList
 67          mock_sql_query.return_value = [address]
 68          return_val = isAddressInMySubscriptionsList(address)
 69          self.assertTrue(return_val)
 70  
 71          # if address is not in MySubscriptionsList
 72          mock_sql_query.return_value = []
 73          return_val = isAddressInMySubscriptionsList(address)
 74          self.assertFalse(return_val)
 75          self.assertEqual(mock_sql_query.call_count, 2)
 76  
 77      @patch("pybitmessage.shared.sqlQuery")
 78      def test_reloadBroadcastSendersForWhichImWatching(self, mock_sql_query):
 79          """Test for reload Broadcast Senders For Which Im Watching"""
 80          mock_sql_query.return_value = [
 81              (sample_address,),
 82          ]
 83          # before reload
 84          self.assertEqual(len(MyECSubscriptionCryptorObjects), 0)
 85  
 86          # reloading with addressVersionNumber 1
 87          reloadBroadcastSendersForWhichImWatching()
 88          self.assertGreater(len(MyECSubscriptionCryptorObjects), 0)
 89  
 90      @patch("pybitmessage.shared.os.stat")
 91      @patch(
 92          "pybitmessage.shared.sys",
 93          new_callable=PropertyMock,  # pylint: disable=used-before-assignment
 94      )
 95      def test_check_sensitive_file_permissions(self, mock_sys, mock_os_stat):
 96          """Test to check file permissions"""
 97          fake_filename = "path/to/file"
 98  
 99          # test for windows system
100          mock_sys.platform = "win32"
101          result = checkSensitiveFilePermissions(fake_filename)
102          self.assertTrue(result)
103  
104          # test for freebsd system
105          mock_sys.platform = "freebsd7"
106          # returning file permission mode stat.S_IRUSR
107          MOCK_OS_STAT_RETURN = os.stat_result(
108              sequence=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
109              dict={
110                  "st_mode": PERMISSION_MODE1,
111                  "st_ino": INODE,
112                  "st_dev": DEV,
113                  "st_nlink": NLINK,
114                  "st_uid": UID,
115                  "st_gid": GID,
116                  "st_size": SIZE,
117                  "st_atime": ATIME,
118                  "st_mtime": MTIME,
119                  "st_ctime": CTIME,
120              },
121          )
122          mock_os_stat.return_value = MOCK_OS_STAT_RETURN
123          result = checkSensitiveFilePermissions(fake_filename)
124          self.assertTrue(result)
125  
126      @patch("pybitmessage.shared.os.chmod")
127      @patch("pybitmessage.shared.os.stat")
128      def test_fix_sensitive_file_permissions(  # pylint: disable=no-self-use
129          self, mock_os_stat, mock_chmod
130      ):
131          """Test to fix file permissions"""
132          fake_filename = "path/to/file"
133  
134          # returning file permission mode stat.S_IRWXO
135          MOCK_OS_STAT_RETURN = os.stat_result(
136              sequence=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
137              dict={
138                  "st_mode": PERMISSION_MODE2,
139                  "st_ino": INODE,
140                  "st_dev": DEV,
141                  "st_nlink": NLINK,
142                  "st_uid": UID,
143                  "st_gid": GID,
144                  "st_size": SIZE,
145                  "st_atime": ATIME,
146                  "st_mtime": MTIME,
147                  "st_ctime": CTIME,
148              },
149          )
150          mock_os_stat.return_value = MOCK_OS_STAT_RETURN
151          fixSensitiveFilePermissions(fake_filename, False)
152          mock_chmod.assert_called_once()