removed tests

tests/test_ai_agent_service.py

@@ -1,202 +0,0 @@
-import unittest
-from unittest.mock import patch, MagicMock
-from sqlalchemy.orm import Session
-from services.ai_agent import preprocess_data, validate_data, clean_data, standardize_data, enrich_data, process_data, integrate_hugging_face_transformers
-from models.product import Product
-from models.ingredient import Ingredient
-
-class TestAIAgentService(unittest.TestCase):
-
-    @patch('services.ai_agent.fetch_product_data_from_api')
-    def test_preprocess_data(self, mock_fetch_product_data_from_api):
-        mock_fetch_product_data_from_api.return_value = {
-            'product': {
-                'product_name_en': 'Test Product',
-                'generic_name_en': 'Test Generic',
-                'brands': 'Test Brand',
-                'ingredients': [
-                    {
-                        'text': 'Test Ingredient',
-                        'percent': 50,
-                        'vegan': 'yes',
-                        'vegetarian': 'yes',
-                        'ingredients': [
-                            {
-                                'text': 'Sub Ingredient',
-                                'percent': 25,
-                                'vegan': 'yes',
-                                'vegetarian': 'yes'
-                            }
-                        ]
-                    }
-                ],
-                'ingredients_text_en': 'Test Ingredients Text',
-                'ingredients_analysis': {},
-                'nutriscore': {},
-                'nutrient_levels': {},
-                'nutriments': {},
-                'data_quality_warnings_tags': []
-            }
-        }
-        result = preprocess_data('test_barcode')
-        self.assertEqual(result['product_name'], 'Test Product')
-        self.assertEqual(result['generic_name'], 'Test Generic')
-        self.assertEqual(result['brands'], 'Test Brand')
-        self.assertEqual(result['ingredients'][0]['text'], 'Test Ingredient')
-        self.assertEqual(result['ingredients'][0]['sub_ingredients'][0]['text'], 'Sub Ingredient')
-
-    def test_validate_data(self):
-        valid_data = {
-            'product_name': 'Test Product',
-            'generic_name': 'Test Generic',
-            'brands': 'Test Brand',
-            'ingredients': [],
-            'nutriscore': {},
-            'nutrient_levels': {},
-            'nutriments': {}
-        }
-        invalid_data = {
-            'product_name': '',
-            'generic_name': '',
-            'brands': '',
-            'ingredients': [],
-            'nutriscore': {},
-            'nutrient_levels': {},
-            'nutriments': {}
-        }
-        self.assertTrue(validate_data(valid_data))
-        self.assertFalse(validate_data(invalid_data))
-
-    def test_clean_data(self):
-        data = {
-            'ingredients': [
-                {
-                    'text': 'Test Ingredient',
-                    'percent': 'N/A',
-                    'sub_ingredients': [
-                        {
-                            'text': 'Sub Ingredient',
-                            'percent': 'N/A'
-                        }
-                    ]
-                }
-            ]
-        }
-        cleaned_data = clean_data(data)
-        self.assertEqual(cleaned_data['ingredients'][0]['percent'], 0)
-        self.assertEqual(cleaned_data['ingredients'][0]['sub_ingredients'][0]['percent'], 0)
-
-    def test_standardize_data(self):
-        data = {
-            'ingredients': [
-                {
-                    'text': 'Test Ingredient',
-                    'sub_ingredients': [
-                        {
-                            'text': 'Sub Ingredient'
-                        }
-                    ]
-                }
-            ]
-        }
-        standardized_data = standardize_data(data)
-        self.assertEqual(standardized_data['ingredients'][0]['text'], 'test ingredient')
-        self.assertEqual(standardized_data['ingredients'][0]['sub_ingredients'][0]['text'], 'sub ingredient')
-
-    @patch('services.ai_agent.get_ingredient_by_name')
-    @patch('services.ai_agent.fetch_product_data_from_api')
-    @patch('services.ai_agent.save_ingredient_data')
-    def test_enrich_data(self, mock_save_ingredient_data, mock_fetch_product_data_from_api, mock_get_ingredient_by_name):
-        db = MagicMock(spec=Session)
-        data = {
-            'ingredients': [
-                {
-                    'text': 'Test Ingredient',
-                    'sub_ingredients': []
-                }
-            ]
-        }
-        mock_get_ingredient_by_name.return_value = None
-        mock_fetch_product_data_from_api.return_value = {'nutritional_info': 'Test Info'}
-        enriched_data = enrich_data(db, data)
-        self.assertEqual(enriched_data['ingredients'][0]['nutritional_info'], {'nutritional_info': 'Test Info'})
-        mock_save_ingredient_data.assert_called_once_with(db, 'Test Ingredient', {'nutritional_info': 'Test Info'})
-
-    @patch('services.ai_agent.preprocess_data')
-    @patch('services.ai_agent.validate_data')
-    @patch('services.ai_agent.clean_data')
-    @patch('services.ai_agent.standardize_data')
-    @patch('services.ai_agent.enrich_data')
-    @patch('services.ai_agent.save_json_file')
-    def test_process_data(self, mock_save_json_file, mock_enrich_data, mock_standardize_data, mock_clean_data, mock_validate_data, mock_preprocess_data):
-        db = MagicMock(spec=Session)
-        mock_preprocess_data.return_value = {'product_name': 'Test Product'}
-        mock_validate_data.return_value = True
-        mock_clean_data.return_value = {'product_name': 'Test Product'}
-        mock_standardize_data.return_value = {'product_name': 'Test Product'}
-        mock_enrich_data.return_value = {'product_name': 'Test Product'}
-        result = process_data(db, 'test_barcode')
-        self.assertEqual(result['product_name'], 'Test Product')
-        mock_save_json_file.assert_called_once_with('test_barcode', {'product_name': 'Test Product'})
-
-    @patch('services.ai_agent.pipeline')
-    def test_integrate_hugging_face_transformers(self, mock_pipeline):
-        mock_pipeline.return_value = lambda text: [{'sequence': 'Test sequence'}]
-        result = integrate_hugging_face_transformers('test_model', 'Test text')
-        self.assertEqual(result, 'Test sequence')
-
-    @patch('services.ai_agent.get_ingredient_by_name')
-    @patch('services.ai_agent.fetch_ingredient_data_from_api')
-    @patch('services.ai_agent.save_ingredient_data')
-    def test_process_data_saves_ingredient_details(self, mock_save_ingredient_data, mock_fetch_ingredient_data_from_api, mock_get_ingredient_by_name):
-        db = MagicMock(spec=Session)
-        mock_get_ingredient_by_name.return_value = None
-        mock_fetch_ingredient_data_from_api.return_value = {'nutritional_info': 'Test Info'}
-        data = {
-            'product_name': 'Test Product',
-            'generic_name': 'Test Generic',
-            'brands': 'Test Brand',
-            'ingredients': [
-                {
-                    'text': 'Test Ingredient',
-                    'sub_ingredients': []
-                }
-            ],
-            'ingredients_text': 'Test Ingredients Text',
-            'ingredients_analysis': {},
-            'nutriscore': {},
-            'nutrient_levels': {},
-            'nutriments': {},
-            'data_quality_warnings': []
-        }
-        with patch('services.ai_agent.preprocess_data', return_value=data), \
-             patch('services.ai_agent.validate_data', return_value=True), \
-             patch('services.ai_agent.clean_data', return_value=data), \
-             patch('services.ai_agent.standardize_data', return_value=data), \
-             patch('services.ai_agent.enrich_data', return_value=data):
-            result = process_data(db, 'test_barcode')
-            self.assertEqual(result['product_name'], 'Test Product')
-            mock_save_ingredient_data.assert_called_once_with(db, 'Test Ingredient', {'nutritional_info': 'Test Info'})
-
-    @patch('services.ai_agent.preprocess_data')
-    @patch('services.ai_agent.validate_data')
-    @patch('services.ai_agent.clean_data')
-    @patch('services.ai_agent.standardize_data')
-    @patch('services.ai_agent.enrich_data')
-    @patch('services.ai_agent.save_json_file')
-    def test_process_data_saves_product_details(self, mock_save_json_file, mock_enrich_data, mock_standardize_data, mock_clean_data, mock_validate_data, mock_preprocess_data):
-        db = MagicMock(spec=Session)
-        mock_preprocess_data.return_value = {'product_name': 'Test Product'}
-        mock_validate_data.return_value = True
-        mock_clean_data.return_value = {'product_name': 'Test Product'}
-        mock_standardize_data.return_value = {'product_name': 'Test Product'}
-        mock_enrich_data.return_value = {'product_name': 'Test Product'}
-        result = process_data(db, 'test_barcode')
-        self.assertEqual(result['product_name'], 'Test Product')
-        mock_save_json_file.assert_called_once_with('test_barcode', {'product_name': 'Test Product'})
-        db.add.assert_called_once()
-        db.commit.assert_called_once()
-        db.refresh.assert_called_once()
-
-if __name__ == '__main__':
-    unittest.main()

tests/test_analysis_agent_service.py

@@ -1,88 +0,0 @@
-import unittest
-from unittest.mock import MagicMock
-from sqlalchemy.orm import Session
-from services.analysis_agent import analyze_ingredients, provide_personalized_recommendations
-from models.user_preferences import UserPreferences
-from models.ingredient import Ingredient
-
-class TestAnalysisAgentService(unittest.TestCase):
-
-    def setUp(self):
-        self.db = MagicMock(spec=Session)
-        self.user_id = 1
-        self.ingredients = [
-            {"text": "sugar"},
-            {"text": "salt"},
-            {"text": "flour"}
-        ]
-        self.preferences = UserPreferences(
-            user_id=self.user_id,
-            dietary_restrictions="low sugar",
-            allergens="",
-            preferred_ingredients="",
-            disliked_ingredients=""
-        )
-        self.db.query.return_value.filter.return_value.first.return_value = self.preferences
-
-    def test_analyze_ingredients(self):
-        self.db.query.return_value.filter.return_value.first.return_value = self.preferences
-        self.db.query.return_value.all.return_value = [
-            Ingredient(name="sugar", nutritional_info={"calories": 100}),
-            Ingredient(name="salt", nutritional_info={"sodium": 200}),
-            Ingredient(name="flour", nutritional_info={"carbs": 300})
-        ]
-
-        result = analyze_ingredients(self.db, self.ingredients, self.user_id)
-
-        self.assertIn("safe_ingredients", result)
-        self.assertIn("unsafe_ingredients", result)
-        self.assertIn("additional_facts", result)
-        self.assertEqual(len(result["safe_ingredients"]), 2)
-        self.assertEqual(len(result["unsafe_ingredients"]), 1)
-
-    def test_provide_personalized_recommendations(self):
-        self.db.query.return_value.all.return_value = [
-            Ingredient(name="sugar", nutritional_info={"calories": 100}),
-            Ingredient(name="salt", nutritional_info={"sodium": 200}),
-            Ingredient(name="flour", nutritional_info={"carbs": 300})
-        ]
-
-        result = provide_personalized_recommendations(self.db, self.user_id)
-
-        self.assertIn("recommended_ingredients", result)
-        self.assertEqual(len(result["recommended_ingredients"]), 3)
-
-    def test_analyze_ingredients_with_new_fields(self):
-        self.db.query.return_value.filter.return_value.first.return_value = self.preferences
-        self.db.query.return_value.all.return_value = [
-            Ingredient(name="sugar", nutritional_info={"calories": 100}, description="Sweetener", origin="USA", allergens="", vegan=True, vegetarian=True),
-            Ingredient(name="salt", nutritional_info={"sodium": 200}, description="Seasoning", origin="India", allergens="", vegan=True, vegetarian=True),
-            Ingredient(name="flour", nutritional_info={"carbs": 300}, description="Baking ingredient", origin="Canada", allergens="", vegan=True, vegetarian=True)
-        ]
-
-        result = analyze_ingredients(self.db, self.ingredients, self.user_id)
-
-        self.assertIn("safe_ingredients", result)
-        self.assertIn("unsafe_ingredients", result)
-        self.assertIn("additional_facts", result)
-        self.assertEqual(len(result["safe_ingredients"]), 2)
-        self.assertEqual(len(result["unsafe_ingredients"]), 1)
-        self.assertEqual(result["safe_ingredients"][0]["description"], "Sweetener")
-        self.assertEqual(result["safe_ingredients"][1]["origin"], "India")
-
-    def test_provide_personalized_recommendations_with_new_fields(self):
-        self.db.query.return_value.all.return_value = [
-            Ingredient(name="sugar", nutritional_info={"calories": 100}, description="Sweetener", origin="USA", allergens="", vegan=True, vegetarian=True),
-            Ingredient(name="salt", nutritional_info={"sodium": 200}, description="Seasoning", origin="India", allergens="", vegan=True, vegetarian=True),
-            Ingredient(name="flour", nutritional_info={"carbs": 300}, description="Baking ingredient", origin="Canada", allergens="", vegan=True, vegetarian=True)
-        ]
-
-        result = provide_personalized_recommendations(self.db, self.user_id)
-
-        self.assertIn("recommended_ingredients", result)
-        self.assertEqual(len(result["recommended_ingredients"]), 3)
-        self.assertEqual(result["recommended_ingredients"][0]["description"], "Sweetener")
-        self.assertEqual(result["recommended_ingredients"][1]["origin"], "India")
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_auth_service.py

@@ -1,56 +0,0 @@
-import pytest
-from fastapi.testclient import TestClient
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-from database import get_db
-from models.base import Base
-from main import app
-from services.auth_service import create_user, get_password_hash
-from models.user import User
-
-SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
-engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
-TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-Base.metadata.create_all(bind=engine)
-
-def override_get_db():
-    try:
-        db = TestingSessionLocal()
-        yield db
-    finally:
-        db.close()
-
-app.dependency_overrides[get_db] = override_get_db
-
-client = TestClient(app)
-
-@pytest.fixture(scope="module")
-def test_db():
-    Base.metadata.create_all(bind=engine)
-    db = TestingSessionLocal()
-    yield db
-    db.close()
-    Base.metadata.drop_all(bind=engine)
-
-def test_register_user(test_db):
-    response = client.post("/api/auth/register", json={"username": "testuser", "email": "testuser@example.com", "password": "testpassword"})
-    assert response.status_code == 200
-    assert "access_token" in response.json()
-    assert response.json()["token_type"] == "bearer"
-
-def test_login_user(test_db):
-    create_user(test_db, "testuser", "testuser@example.com", get_password_hash("testpassword"))
-    response = client.post("/api/auth/login", data={"username": "testuser", "password": "testpassword"})
-    assert response.status_code == 200
-    assert "access_token" in response.json()
-    assert response.json()["token_type"] == "bearer"
-
-def test_get_current_user(test_db):
-    create_user(test_db, "testuser", "testuser@example.com", get_password_hash("testpassword"))
-    response = client.post("/api/auth/login", data={"username": "testuser", "password": "testpassword"})
-    token = response.json()["access_token"]
-    response = client.get("/api/auth/users/me", headers={"Authorization": f"Bearer {token}"})
-    assert response.status_code == 200
-    assert response.json()["username"] == "testuser"
-    assert response.json()["email"] == "testuser@example.com"

tests/test_ingredients_service.py

@@ -1,80 +0,0 @@
-import unittest
-from unittest.mock import patch, MagicMock
-from sqlalchemy.orm import Session
-from services.ingredients import get_ingredient_data, save_ingredient_data, filter_ingredients_by_preferences
-
-class TestIngredientService(unittest.TestCase):
-
-    @patch('services.ingredients.get_ingredient_by_name')
-    @patch('services.ingredients.fetch_ingredient_data_from_api')
-    @patch('services.ingredients.save_ingredient_data')
-    def test_get_ingredient_data(self, mock_save_ingredient_data, mock_fetch_ingredient_data_from_api, mock_get_ingredient_by_name):
-        db = MagicMock(spec=Session)
-        mock_get_ingredient_by_name.return_value = None
-        mock_fetch_ingredient_data_from_api.return_value = {
-            "nutritional_info": "test_info",
-            "description": "test_description",
-            "origin": "test_origin",
-            "allergens": "test_allergens",
-            "vegan": True,
-            "vegetarian": True
-        }
-
-        result = get_ingredient_data(db, "test_ingredient")
-
-        mock_get_ingredient_by_name.assert_called_once_with(db, "test_ingredient")
-        mock_fetch_ingredient_data_from_api.assert_called_once_with("test_ingredient")
-        mock_save_ingredient_data.assert_called_once_with(db, "test_ingredient", {
-            "nutritional_info": "test_info",
-            "description": "test_description",
-            "origin": "test_origin",
-            "allergens": "test_allergens",
-            "vegan": True,
-            "vegetarian": True
-        })
-        self.assertEqual(result, {
-            "nutritional_info": "test_info",
-            "description": "test_description",
-            "origin": "test_origin",
-            "allergens": "test_allergens",
-            "vegan": True,
-            "vegetarian": True
-        })
-
-    def test_save_ingredient_data(self):
-        db = MagicMock(spec=Session)
-        name = "test_ingredient"
-        data = {
-            "nutritional_info": "test_info",
-            "description": "test_description",
-            "origin": "test_origin",
-            "allergens": "test_allergens",
-            "vegan": True,
-            "vegetarian": True
-        }
-
-        save_ingredient_data(db, name, data)
-
-        db.add.assert_called_once()
-        db.commit.assert_called_once()
-        db.refresh.assert_called_once()
-
-    def test_filter_ingredients_by_preferences(self):
-        ingredients = [
-            {"text": "ingredient1", "sugar": 10, "fat": 5, "allergens": ["allergen1"]},
-            {"text": "ingredient2", "sugar": 3, "fat": 2, "allergens": []},
-            {"text": "ingredient3", "sugar": 6, "fat": 1, "allergens": ["allergen2"]}
-        ]
-        preferences = {
-            "low_sugar": True,
-            "low_fat": True,
-            "allergens": ["allergen1"]
-        }
-
-        result = filter_ingredients_by_preferences(ingredients, preferences)
-
-        self.assertEqual(len(result), 1)
-        self.assertEqual(result[0]["text"], "ingredient2")
-
-if __name__ == '__main__':
-    unittest.main()

tests/test_scan_history_service.py

@@ -1,43 +0,0 @@
-import unittest
-from unittest.mock import MagicMock
-from datetime import datetime
-from sqlalchemy.orm import Session
-from models.scan_history import ScanHistory
-from services.scan_history import record_scan, get_scan_history
-
-class TestScanHistoryService(unittest.TestCase):
-
-    def setUp(self):
-        self.db = MagicMock(spec=Session)
-        self.user_id = 1
-        self.product_id = 123
-        self.scan_date = datetime.utcnow()
-
-    def test_record_scan(self):
-        scan_entry = ScanHistory(user_id=self.user_id, product_id=self.product_id, scan_date=self.scan_date)
-        self.db.add.return_value = None
-        self.db.commit.return_value = None
-        self.db.refresh.return_value = None
-
-        result = record_scan(self.db, self.user_id, self.product_id)
-
-        self.db.add.assert_called_once_with(scan_entry)
-        self.db.commit.assert_called_once()
-        self.db.refresh.assert_called_once_with(scan_entry)
-        self.assertEqual(result.user_id, self.user_id)
-        self.assertEqual(result.product_id, self.product_id)
-        self.assertEqual(result.scan_date, self.scan_date)
-
-    def test_get_scan_history(self):
-        scan_entry = ScanHistory(user_id=self.user_id, product_id=self.product_id, scan_date=self.scan_date)
-        self.db.query.return_value.filter.return_value.all.return_value = [scan_entry]
-
-        result = get_scan_history(self.db, self.user_id)
-
-        self.db.query.assert_called_once_with(ScanHistory)
-        self.db.query.return_value.filter.assert_called_once_with(ScanHistory.user_id == self.user_id)
-        self.db.query.return_value.filter.return_value.all.assert_called_once()
-        self.assertEqual(result, [scan_entry])
-
-if __name__ == '__main__':
-    unittest.main()