Coverage for tests/services/test_log_service.py: 100%

1import pytest 

2from unittest.mock import patch, MagicMock 

3from app.services import log_service 

4 

5 

6def mock_execute_with_data(data): 

7 mock_response = MagicMock() 

8 mock_response.data = data 

9 return mock_response 

10 

11 

12@patch("app.services.log_service.client", new_callable=MagicMock) 

13def test_log_event_success(mock_client, app): 

14 mock_table = MagicMock() 

15 mock_insert = MagicMock() 

16 mock_execute = MagicMock() 

17 

18 mock_client.table.return_value = mock_table 

19 mock_table.insert.return_value = mock_insert 

20 mock_insert.execute.return_value = None 

21 

22 event = {"event": "test", "metadata": {"user_id": "abc"}} 

23 

24 log_service.log_event(event) 

25 

26 mock_client.table.assert_called_once_with("logs") 

27 mock_table.insert.assert_called_once_with(event) 

28 mock_insert.execute.assert_called_once() 

29 

30 

31@patch("app.services.log_service.client", new_callable=MagicMock) 

32def test_log_suggestion_success(mock_client, app): 

33 mock_table = MagicMock() 

34 mock_insert = MagicMock() 

35 mock_execute = MagicMock() 

36 mock_execute.data = [{"id": "abc123"}] 

37 

38 mock_client.table.return_value = mock_table 

39 mock_table.insert.return_value = mock_insert 

40 mock_insert.execute.return_value = mock_execute 

41 

42 suggestion = { 

43 "event": "suggestion", 

44 "metadata": {}, 

45 } 

46 

47 result = log_service.log_suggestion(suggestion) 

48 

49 assert result["id"] == "abc123" 

50 mock_client.table.assert_called_with("suggestions") 

51 mock_table.insert.assert_called_once_with(suggestion) 

52 

53 

54@patch("app.services.log_service.client", new_callable=MagicMock) 

55def test_log_suggestion_failure_no_data(mock_client, app): 

56 mock_table = MagicMock() 

57 mock_insert = MagicMock() 

58 mock_execute = MagicMock() 

59 mock_execute.data = None 

60 

61 mock_client.table.return_value = mock_table 

62 mock_table.insert.return_value = mock_insert 

63 mock_insert.execute.return_value = mock_execute 

64 

65 with pytest.raises(Exception, match="No data returned from insert operation"): 

66 log_service.log_suggestion({"event": "fail", "metadata": {}}) 

67 

68 

69@patch("app.services.log_service.client", new_callable=MagicMock) 

70def test_get_all_logs(mock_client, app): 

71 mock_table = MagicMock() 

72 mock_select = MagicMock() 

73 mock_execute = mock_execute_with_data([{"event": "test"}]) 

74 

75 mock_client.table.return_value = mock_table 

76 mock_table.select.return_value = mock_select 

77 mock_select.execute.return_value = mock_execute 

78 

79 result = log_service.get_all_logs() 

80 assert result == [{"event": "test"}] 

81 

82 

83@patch("app.services.log_service.client", new_callable=MagicMock) 

84def test_get_logs_by_user(mock_client, app): 

85 mock_table = MagicMock() 

86 mock_select = MagicMock() 

87 mock_eq = MagicMock() 

88 mock_execute = mock_execute_with_data([{"event": "test"}]) 

89 

90 mock_client.table.return_value = mock_table 

91 mock_table.select.return_value = mock_select 

92 mock_select.eq.return_value = mock_eq 

93 mock_eq.execute.return_value = mock_execute 

94 

95 result = log_service.get_logs_by_user("user123") 

96 assert result == [{"event": "test"}] 

97 

98 

99@patch("app.services.log_service.client", new_callable=MagicMock) 

100def test_get_logs_by_user_with_section_and_class(mock_client, app): 

101 # Set up chained .eq().eq().eq().execute().data 

102 mock_execute = MagicMock() 

103 mock_execute.data = [{"event": "test"}] 

104 

105 mock_eq3 = MagicMock() 

106 mock_eq3.execute.return_value = mock_execute 

107 

108 mock_eq2 = MagicMock() 

109 mock_eq2.eq.return_value = mock_eq3 

110 

111 mock_eq1 = MagicMock() 

112 mock_eq1.eq.return_value = mock_eq2 

113 

114 mock_select = MagicMock() 

115 mock_select.eq.return_value = mock_eq1 

116 

117 mock_table = MagicMock() 

118 mock_table.select.return_value = mock_select 

119 

120 mock_client.table.return_value = mock_table 

121 

122 result = log_service.get_logs_by_user("user123", "sec1", "class1") 

123 assert result == [{"event": "test"}] 

124 

125 

126@patch("app.services.log_service.client", new_callable=MagicMock) 

127def test_get_logs_by_class(mock_client, app): 

128 mock_table = MagicMock() 

129 mock_select = MagicMock() 

130 mock_eq = MagicMock() 

131 mock_execute = mock_execute_with_data([{"event": "class-log"}]) 

132 

133 mock_client.table.return_value = mock_table 

134 mock_table.select.return_value = mock_select 

135 mock_select.eq.return_value = mock_eq 

136 mock_eq.execute.return_value = mock_execute 

137 

138 result = log_service.get_logs_by_class("class123") 

139 assert result == [{"event": "class-log"}] 

140 

141 

142@patch("app.services.log_service.client", new_callable=MagicMock) 

143def test_get_ai_usage(mock_client, app): 

144 mock_table = MagicMock() 

145 mock_select = MagicMock() 

146 mock_execute = mock_execute_with_data([{"usage": 10}]) 

147 

148 mock_client.table.return_value = mock_table 

149 mock_table.select.return_value = mock_select 

150 mock_select.execute.return_value = mock_execute 

151 

152 result = log_service.get_ai_usage() 

153 assert result == [{"usage": 10}] 

154 

155 

156@patch("app.services.log_service.client", new_callable=MagicMock) 

157def test_get_all_data_from_db(mock_client, app): 

158 mock_client.table.return_value.select.return_value.execute.side_effect = [ 

159 mock_execute_with_data([{"id": "user1"}]), 

160 mock_execute_with_data([{"id": "cu1"}]), 

161 mock_execute_with_data([{"id": "class1"}]), 

162 mock_execute_with_data([{"event": "log1"}]), 

163 mock_execute_with_data([{"id": "suggest1"}]), 

164 mock_execute_with_data([{"id": "usq1"}]), 

165 mock_execute_with_data([{"id": "us1"}]), 

166 ] 

167 

168 result = log_service.get_all_data_from_db() 

169 

170 assert result["users"][0]["id"] == "user1" 

171 assert result["logs"][0]["event"] == "log1" 

172 assert "user_sections" in result