test: add tests for filtering

models.py

@@ -105,11 +105,14 @@ class NostrFilter(BaseModel):
         return True
 
     def tag_in_list(self, event_tags, tag_name) -> bool:
-        tag_values = [t[1] for t in event_tags if t[0] == tag_name]
-        if len(tag_values) == 0:
-            return True
         filter_tags = dict(self).get(tag_name, [])
-        common_tags = [t for t in tag_values if t in filter_tags]
+        if len(filter_tags) == 0:
+            return True
+
+        #filter has tag
+        event_tag_values = [t[1] for t in event_tags if t[0] == tag_name]
+        
+        common_tags = [event_tag for event_tag in event_tag_values if event_tag in filter_tags]
         if len(common_tags) == 0:
             return False
         return True

tests/test_events.py

@@ -9,6 +9,7 @@ from lnbits.extensions.nostrrelay.crud import create_event, get_event, get_event
 from lnbits.extensions.nostrrelay.models import NostrEvent, NostrFilter
 
 FIXTURES_PATH = "tests/extensions/nostrrelay/fixture"
+RELAY_ID = "r1"
 
 class EventFixture(BaseModel):
     name: str
@@ -42,72 +43,103 @@ def test_invalid_event_id_and_signature(invalid_events: List[EventFixture]):
 
 
 @pytest.mark.asyncio
-async def test_valid_event_crud(valid_events: List[EventFixture]):
+async def test_valid_event_crud(valid_events: List[EventFixture]):    
-    relay_id = "r1"
-    for f in valid_events:
-        await create_event(relay_id, f.data)
-
-    # insert all events before doing an query
-    for f in valid_events:   
-        await get_by_id(relay_id, f.data, f.name)
-        await filter_by_id(relay_id, f.data, f.name)
-
     author = "a24496bca5dd73300f4e5d5d346c73132b7354c597fcbb6509891747b4689211"
     event_id = "3219eec7427e365585d5adf26f5d2dd2709d3f0f2c0e1f79dc9021e951c67d96"
     reply_event_id = "6b2b6cb9c72caaf3dfbc5baa5e68d75ac62f38ec011b36cc83832218c36e4894"
+    all_events = [f.data for f in valid_events]
+
+    for e in all_events:
+        await create_event(RELAY_ID, e)
+
+    # insert all events before doing an query
+    for f in valid_events:   
+        await get_by_id(f.data, f.name)
+        await filter_by_id(all_events, f.data, f.name)
+
     
-    await filter_by_author(relay_id, author)
+    await filter_by_author(all_events, author)
 
-    await filter_by_tag_p(relay_id, author)
+    await filter_by_tag_p(all_events, author)
 
-    await filter_by_tag_e(relay_id, event_id)
+    await filter_by_tag_e(all_events, event_id)
 
-    await filter_by_tag_e_and_p(relay_id, author, event_id, reply_event_id)
+    await filter_by_tag_e_and_p(all_events, author, event_id, reply_event_id)
 
-    await filter_by_tag_e_p_and_author(relay_id, author, event_id, reply_event_id)
+    await filter_by_tag_e_p_and_author(all_events, author, event_id, reply_event_id)
 
-async def get_by_id(relay_id:str, data: NostrEvent, test_name: str):
+async def get_by_id(data: NostrEvent, test_name: str):
-    event = await get_event(relay_id, data.id)
+    event = await get_event(RELAY_ID, data.id)
     assert event, f"Failed to restore event (id='{data.id}')"
     assert event.json() != json.dumps(data.json()), f"Restored event is different for fixture '{test_name}'"
 
-async def filter_by_id(relay_id, data: NostrEvent, test_name: str):
+async def filter_by_id(all_events: List[NostrEvent], data: NostrEvent, test_name: str):
     filter = NostrFilter(ids=[data.id])
-    events = await get_events(relay_id, filter)
-    assert len(events) == 1, f"Expected one filter event '{test_name}'"
-    assert events[0].json() != json.dumps(data.json()), f"FIlter event is different for fixture '{test_name}'"
 
-async def filter_by_tag_e_p_and_author(relay_id, author, event_id, reply_event_id):
+    events = await get_events(RELAY_ID, filter)
+    assert len(events) == 1, f"Expected one queried event '{test_name}'"
+    assert events[0].json() != json.dumps(data.json()), f"Queried event is different for fixture '{test_name}'"
+
+    filtered_events = [e for e in all_events if filter.matches(e)]
+    assert len(filtered_events) == 1, f"Expected one filter event '{test_name}'"
+    assert filtered_events[0].json() != json.dumps(data.json()), f"Filtered event is different for fixture '{test_name}'"
+    
+
+async def filter_by_author(all_events: List[NostrEvent], author):
+    filter = NostrFilter(authors=[author])
+    events_by_author = await get_events(RELAY_ID, filter)
+    assert len(events_by_author) == 5, f"Failed to query by authors"
+
+    filtered_events = [e for e in all_events if filter.matches(e)]
+    assert len(filtered_events) == 5, f"Failed to filter by authors"
+
+async def filter_by_tag_p(all_events: List[NostrEvent], author):
+    # todo: check why constructor does not work for fields with aliases (#e, #p)
+    filter = NostrFilter() 
+    filter.p.append(author)
+
+    events_related_to_author = await get_events(RELAY_ID, filter)
+    assert len(events_related_to_author) == 5, f"Failed to query by tag 'p'"
+
+    filtered_events = [e for e in all_events if filter.matches(e)]
+    assert len(filtered_events) == 5, f"Failed to filter by tag 'p'"
+
+
+async def filter_by_tag_e(all_events: List[NostrEvent],  event_id):
+    filter = NostrFilter()
+    filter.e.append(event_id)
+
+    events_related_to_event = await get_events(RELAY_ID, filter)
+    assert len(events_related_to_event) == 2, f"Failed to query by tag 'e'"
+
+    filtered_events = [e for e in all_events if filter.matches(e)]
+    assert len(filtered_events) == 2, f"Failed to filter by tag 'e'"
+
+async def filter_by_tag_e_and_p(all_events: List[NostrEvent],  author, event_id, reply_event_id):
+    filter = NostrFilter()
+    filter.p.append(author)
+    filter.e.append(event_id)
+    
+    events_related_to_event = await get_events(RELAY_ID, filter)
+    assert len(events_related_to_event) == 1, f"Failed to quert by tags 'e' & 'p'"
+    assert events_related_to_event[0].id == reply_event_id, f"Failed to query the right event by tags 'e' & 'p'"
+
+    filtered_events = [e for e in all_events if filter.matches(e)]
+    assert len(filtered_events) == 1, f"Failed to filter by tags 'e' & 'p'"
+    assert filtered_events[0].id == reply_event_id, f"Failed to find the right event by tags 'e' & 'p'"
+
+async def filter_by_tag_e_p_and_author(all_events: List[NostrEvent], author, event_id, reply_event_id):
     filter = NostrFilter(authors=[author])
     filter.p.append(author)
     filter.e.append(event_id)
-    events_related_to_event = await get_events(relay_id, filter)
+    events_related_to_event = await get_events(RELAY_ID, filter)
-    assert len(events_related_to_event) == 1, f"Failed to filter by 'author' and tags 'e' & 'p'"
+    assert len(events_related_to_event) == 1, f"Failed to query by 'author' and tags 'e' & 'p'"
-    assert events_related_to_event[0].id == reply_event_id, f"Failed to find the right event by 'author' and tags 'e' & 'p'"
+    assert events_related_to_event[0].id == reply_event_id, f"Failed to query the right event by 'author' and tags 'e' & 'p'"
 
-async def filter_by_tag_e_and_p(relay_id, author, event_id, reply_event_id):
+    filtered_events = [e for e in all_events if filter.matches(e)]
-    filter = NostrFilter()
+    assert len(filtered_events) == 1, f"Failed to filter by 'author' and tags 'e' & 'p'"
-    filter.p.append(author)
+    assert filtered_events[0].id == reply_event_id, f"Failed to filter the right event by 'author' and tags 'e' & 'p'"
-    filter.e.append(event_id)
-    events_related_to_event = await get_events(relay_id, filter)
-    assert len(events_related_to_event) == 1, f"Failed to filter by tags 'e' & 'p'"
-    assert events_related_to_event[0].id == reply_event_id, f"Failed to find the right event by tags 'e' & 'p'"
 
-async def filter_by_tag_e(relay_id, event_id):
-    filter = NostrFilter()
-    filter.e.append(event_id)
-    events_related_to_event = await get_events(relay_id, filter)
-    assert len(events_related_to_event) == 2, f"Failed to filter by tag 'e'"
-
-async def filter_by_tag_p(relay_id, author):
-    filter = NostrFilter() # todo: check why constructor does not work for fields with aliases (#e, #p)
-    filter.p.append(author)
-    events_related_to_author = await get_events(relay_id, filter)
-    assert len(events_related_to_author) == 5, f"Failed to filter by tag 'p'"
-
-async def filter_by_author(relay_id, author):
-    events_by_author = await get_events(relay_id, NostrFilter(authors=[author]))
-    assert len(events_by_author) == 5, f"Failed to filter by authors"