vfbquery 0.4.1__py3-none-any.whl → 0.5.1__py3-none-any.whl

test/test_new_owlery_queries.py

@@ -0,0 +1,282 @@
+"""
+Tests for newly implemented Owlery-based queries:
+- NeuronsSynaptic
+- NeuronsPresynapticHere
+- NeuronsPostsynapticHere
+- ComponentsOf
+- PartsOf
+- SubclassesOf
+"""
+
+import unittest
+from vfbquery.vfb_queries import (
+    get_neurons_with_synapses_in,
+    get_neurons_with_presynaptic_terminals_in,
+    get_neurons_with_postsynaptic_terminals_in,
+    get_components_of,
+    get_parts_of,
+    get_subclasses_of,
+    get_term_info
+)
+
+
+class TestNeuronsSynaptic(unittest.TestCase):
+    """Tests for NeuronsSynaptic query"""
+    
+    def setUp(self):
+        self.medulla_id = 'FBbt_00003748'  # medulla - synaptic neuropil
+    
+    def test_neurons_synaptic_returns_results(self):
+        """Test that NeuronsSynaptic query returns results for medulla"""
+        result = get_neurons_with_synapses_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_neurons_synaptic_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_neurons_with_synapses_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_neurons_synaptic_in_term_info(self):
+        """Test that NeuronsSynaptic appears in term_info queries"""
+        term_info = get_term_info(self.medulla_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Neurons with synaptic terminals in {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+class TestNeuronsPresynapticHere(unittest.TestCase):
+    """Tests for NeuronsPresynapticHere query"""
+    
+    def setUp(self):
+        self.medulla_id = 'FBbt_00003748'  # medulla - synaptic neuropil
+    
+    def test_neurons_presynaptic_returns_results(self):
+        """Test that NeuronsPresynapticHere query returns results for medulla"""
+        result = get_neurons_with_presynaptic_terminals_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_neurons_presynaptic_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_neurons_with_presynaptic_terminals_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_neurons_presynaptic_in_term_info(self):
+        """Test that NeuronsPresynapticHere appears in term_info queries"""
+        term_info = get_term_info(self.medulla_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Neurons with presynaptic terminals in {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+class TestNeuronsPostsynapticHere(unittest.TestCase):
+    """Tests for NeuronsPostsynapticHere query"""
+    
+    def setUp(self):
+        self.medulla_id = 'FBbt_00003748'  # medulla - synaptic neuropil
+    
+    def test_neurons_postsynaptic_returns_results(self):
+        """Test that NeuronsPostsynapticHere query returns results for medulla"""
+        result = get_neurons_with_postsynaptic_terminals_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_neurons_postsynaptic_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_neurons_with_postsynaptic_terminals_in(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_neurons_postsynaptic_in_term_info(self):
+        """Test that NeuronsPostsynapticHere appears in term_info queries"""
+        term_info = get_term_info(self.medulla_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Neurons with postsynaptic terminals in {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+class TestComponentsOf(unittest.TestCase):
+    """Tests for ComponentsOf query"""
+    
+    def setUp(self):
+        self.clone_id = 'FBbt_00110369'  # adult SLPpm4 lineage clone
+    
+    def test_components_of_returns_results(self):
+        """Test that ComponentsOf query returns results for clone"""
+        result = get_components_of(
+            self.clone_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_components_of_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_components_of(
+            self.clone_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_components_of_in_term_info(self):
+        """Test that ComponentsOf appears in term_info queries"""
+        term_info = get_term_info(self.clone_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Components of {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+class TestPartsOf(unittest.TestCase):
+    """Tests for PartsOf query"""
+    
+    def setUp(self):
+        self.medulla_id = 'FBbt_00003748'  # medulla - any Class
+    
+    def test_parts_of_returns_results(self):
+        """Test that PartsOf query returns results for medulla"""
+        result = get_parts_of(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_parts_of_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_parts_of(
+            self.medulla_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_parts_of_in_term_info(self):
+        """Test that PartsOf appears in term_info queries"""
+        term_info = get_term_info(self.medulla_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Parts of {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+class TestSubclassesOf(unittest.TestCase):
+    """Tests for SubclassesOf query"""
+    
+    def setUp(self):
+        self.wedge_pn_id = 'FBbt_00048516'  # wedge projection neuron (>45 subclasses)
+    
+    def test_subclasses_of_returns_results(self):
+        """Test that SubclassesOf query returns results for wedge projection neuron"""
+        result = get_subclasses_of(
+            self.wedge_pn_id,
+            return_dataframe=False
+        )
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headers', result)
+        self.assertIn('rows', result)
+        self.assertIn('count', result)
+    
+    def test_subclasses_of_has_expected_columns(self):
+        """Test that result has expected column structure"""
+        result = get_subclasses_of(
+            self.wedge_pn_id,
+            return_dataframe=False
+        )
+        
+        headers = result['headers']
+        self.assertIn('id', headers)
+        self.assertIn('label', headers)
+        self.assertIn('tags', headers)
+        self.assertIn('thumbnail', headers)
+    
+    def test_subclasses_of_in_term_info(self):
+        """Test that SubclassesOf appears in term_info queries"""
+        term_info = get_term_info(self.wedge_pn_id, preview=True)
+        
+        self.assertIn('Queries', term_info)  # Note: Capital 'Q'
+        query_labels = [q['label'] for q in term_info['Queries']]
+        
+        # Check if our query is present
+        expected_label = f"Subclasses of {term_info['Name']}"
+        self.assertIn(expected_label, query_labels)
+
+
+if __name__ == '__main__':
+    unittest.main()

test/test_publication_transgene_queries.py

@@ -0,0 +1,101 @@
+"""
+Unit tests for publication and transgene queries.
+
+This tests:
+1. get_terms_for_pub - Terms referencing a publication
+2. get_transgene_expression_here - Complex transgene expression query
+
+Test terms:
+- DOI_10_7554_eLife_04577 - Example publication
+- FBbt_00003748 - mushroom body (for transgene expression)
+"""
+
+import unittest
+import sys
+import os
+
+# Add src directory to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+
+from vfbquery.vfb_queries import (
+    get_terms_for_pub,
+    get_transgene_expression_here,
+    TermsForPub_to_schema,
+    TransgeneExpressionHere_to_schema
+)
+
+
+class PublicationTransgeneQueriesTest(unittest.TestCase):
+    """Test cases for publication and transgene queries"""
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.pub_term = 'DOI_10_7554_eLife_04577'  # Example publication
+        self.anatomy_term = 'FBbt_00003748'  # mushroom body
+        
+    def test_get_terms_for_pub(self):
+        """Test get_terms_for_pub query"""
+        result = get_terms_for_pub(self.pub_term, return_dataframe=True, limit=10)
+        self.assertIsNotNone(result, "Result should not be None")
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            print(f"\n✓ Found {len(result)} terms for publication {self.pub_term}")
+            self.assertIn('id', result.columns)
+            self.assertIn('label', result.columns)
+            
+    def test_get_terms_for_pub_formatted(self):
+        """Test get_terms_for_pub with formatted output"""
+        result = get_terms_for_pub(self.pub_term, return_dataframe=False, limit=5)
+        self.assertIsNotNone(result)
+        
+        if isinstance(result, dict):
+            self.assertIn('headers', result)
+            self.assertIn('rows', result)
+            
+    def test_get_transgene_expression_here(self):
+        """Test get_transgene_expression_here query"""
+        result = get_transgene_expression_here(self.anatomy_term, return_dataframe=True, limit=10)
+        self.assertIsNotNone(result, "Result should not be None")
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            print(f"\n✓ Found {len(result)} transgene expressions in {self.anatomy_term}")
+            self.assertIn('id', result.columns)
+            
+    def test_get_transgene_expression_formatted(self):
+        """Test get_transgene_expression_here with formatted output"""
+        result = get_transgene_expression_here(self.anatomy_term, return_dataframe=False, limit=5)
+        self.assertIsNotNone(result)
+        
+        if isinstance(result, dict):
+            self.assertIn('headers', result)
+            self.assertIn('rows', result)
+            
+    def test_schema_functions_exist(self):
+        """Test that publication/transgene schema functions exist and are callable"""
+        schema_functions = [
+            TermsForPub_to_schema,
+            TransgeneExpressionHere_to_schema
+        ]
+        
+        for func in schema_functions:
+            self.assertTrue(callable(func), f"{func.__name__} should be callable")
+            
+    def test_limit_parameter(self):
+        """Test that limit parameter works correctly"""
+        result = get_terms_for_pub(self.pub_term, return_dataframe=True, limit=3)
+        
+        import pandas as pd
+        if isinstance(result, pd.DataFrame) and len(result) > 0:
+            self.assertLessEqual(len(result), 3, "Result should respect limit parameter")
+            
+    def test_empty_results_handling(self):
+        """Test that queries handle empty results gracefully"""
+        # Use a term unlikely to have references
+        result = get_terms_for_pub('INVALID_PUB_123', return_dataframe=True, limit=5)
+        self.assertIsNotNone(result)
+
+
+if __name__ == '__main__':
+    unittest.main()