def test_persisted_offset(self, *, store): with pytest.raises(NotImplementedError): store.persisted_offset(TP("foo", 0))
def _new_topicpartition(self, *args, **kwargs): return TP(*args, **kwargs)
def test_is_changelog_tp(self, *, app, consumer): app.tables = Mock(name="tables", autospec=TableManager) app.tables.changelog_topics = {"foo", "bar"} assert consumer._is_changelog_tp(TP("foo", 31)) assert consumer._is_changelog_tp(TP("bar", 0)) assert not consumer._is_changelog_tp(TP("baz", 3))
def test_persisted_offset(self, *, store): assert store.persisted_offset(TP("foo", 0)) is None
def ensure_TP(tp: Any) -> TP: return tp if isinstance(tp, TP) else TP(tp.topic, tp.partition)
from collections import Counter import pytest from faust.tables.recovery import RebalanceAgain, Recovery, ServiceStopped from faust.types import TP from mode.utils.mocks import AsyncMock, Mock TP1 = TP('foo', 6) TP2 = TP('bar', 3) TP3 = TP('baz', 1) TP4 = TP('xuz', 0) @pytest.fixture() def tables(): return Mock(name='tables') @pytest.fixture() def recovery(*, tables, app): return Recovery(app, tables) class test_Recovery: @pytest.fixture() def table(self): return Mock(name='table') def test_init(self, *, recovery, tables): assert recovery.tables is tables assert recovery.signal_recovery_start assert recovery.signal_recovery_end
import asyncio import operator from copy import copy import pytest from mode import label, shortlabel from mode.utils.mocks import AsyncMock, Mock, call, patch from faust import Event, Record, Stream, Topic, joins from faust.exceptions import PartitionsMismatch from faust.stores.base import Store from faust.tables.base import Collection from faust.types import TP from faust.windows import Window TP1 = TP("foo", 0) class User(Record): id: str name: str class MyTable(Collection): def __post_init__(self, *args, **kwargs): self.datas = {} def _has_key(self, key): return key in self.datas def _get_key(self, key):
async def test_on_partitions_assigned__isolated(self, *, isolated_agent): assigned = {TP('foo', 0)} i = isolated_agent.on_isolated_partitions_assigned = AsyncMock() await isolated_agent.on_partitions_assigned(assigned) i.assert_called_once_with(assigned)
async def test_on_isolated_partitions_assigned(self, *, agent): agent._assign_isolated_partition = AsyncMock(name='aip') await agent.on_isolated_partitions_assigned({TP('foo', 0)}) agent._assign_isolated_partition.assert_called_once_with(TP('foo', 0))
async def test_on_partitions_revoked__isolated(self, *, isolated_agent): revoked = {TP('foo', 0)} i = isolated_agent.on_isolated_partitions_revoked = AsyncMock(name='i') await isolated_agent.on_partitions_revoked(revoked) i.assert_called_once_with(revoked)
async def test_on_partitions_assigned(self, *, agent): assigned = {TP('foo', 0)} agent.on_shared_partitions_assigned = AsyncMock(name='ospr') await agent.on_partitions_assigned(assigned) agent.on_shared_partitions_assigned.assert_called_once_with(assigned)
def assignment(self) -> Set[TP]: return { TP(t, 0) for t in cast(Transport, self.transport)._subscription }
async def test_need_active_standby_for(self, *, store): assert await store.need_active_standby_for(TP("foo", 0))
def test_set_persisted_offset(self, *, store): store.set_persisted_offset(TP("foo", 0), 30303)
async def test_on_isolated_partition_assigned(self, *, actor): await actor.on_isolated_partition_assigned(TP('foo', 0))
async def test_start_isolated(self, *, agent): agent._start_for_partitions = AsyncMock( name='agent._start_for_partitions', ) ret = await agent._start_isolated(TP('foo', 0)) agent._start_for_partitions.assert_called_once_with({TP('foo', 0)}) assert ret is agent._start_for_partitions.coro()
import asyncio import pytest from faust import App, Channel, Topic from faust.transport.consumer import Consumer from faust.transport.conductor import Conductor from faust.types import Message, TP from mode import label, shortlabel from mode.utils.futures import done_future from mode.utils.mocks import AsyncMock, Mock TP1 = TP('foo', 0) TP2 = TP('foo', 1) class test_Conductor: @pytest.fixture def con(self, *, app): return Conductor(app) def test_constructor(self, *, con): assert con._topics == set() assert con._topic_name_index == {} assert con._tp_index == {} assert con._tp_to_callback == {} assert con._acking_topics == set() assert con._subscription_changed is None assert con._subscription_done is None assert con._compiler assert con.on_message @pytest.mark.asyncio
def test_stream__active_partitions(self, *, agent): assert agent.stream(active_partitions={TP('foo', 0)})
import pytest from faust.exceptions import ImproperlyConfigured from faust.sensors.datadog import DatadogMonitor, DatadogStatsClient from faust.types import TP from mode.utils.mocks import ANY, Mock, call TP1 = TP('foo', 3) @pytest.fixture() def dogstatsd(*, monkeypatch): dogstatsd = Mock(name='dogstatsd') monkeypatch.setattr('faust.sensors.datadog.DogStatsd', dogstatsd) return dogstatsd @pytest.fixture() def statsd(*, monkeypatch): statsd = Mock(name='datadog') monkeypatch.setattr('faust.sensors.datadog.datadog', statsd) return statsd class test_DatadogStatsClient: @pytest.fixture() def client(self, *, dogstatsd, statsd): return DatadogStatsClient() def test_incr(self, *, client): client.incr('metric', count=3)
def assignment(self) -> Set[TP]: """Return the current assignment.""" return { TP(t, 0) for t in cast(Transport, self.transport)._subscription }
async def on_message(message: Message) -> None: tp = TP(topic=message.topic, partition=0) return await get_callback_for_tp(tp)(message)
def _new_topicpartition(self, topic: str, partition: int) -> TP: return TP(topic, partition)
def _leader_tp(self) -> TP: return TP(self._leader_topic_name, 0)
import pytest from faust import Event, Stream, Table, Topic from faust.assignor import PartitionAssignor from faust.sensors import Sensor from faust.transport.consumer import Consumer from faust.transport.producer import Producer from faust.types import Message, TP from mode.utils.mocks import Mock TP1 = TP('foo', 0) @pytest.fixture def message(): return Mock(name='message', autospec=Message) @pytest.fixture def stream(): return Mock(name='stream', autospec=Stream) @pytest.fixture def event(): return Mock(name='event', autospec=Event) @pytest.fixture def topic(): return Mock(name='topic', autospec=Topic)
from faust.app._attached import Attachments from faust.exceptions import AlreadyConfiguredWarning from faust.tables.manager import TableManager from faust.transport.base import Producer, Transport from faust.transport.conductor import Conductor from faust.transport.consumer import ( Consumer, ConsumerThread, Fetcher, ProducerSendError, ThreadDelegateConsumer, TransactionManager, ) from faust.types import TP, Message TP1 = TP("foo", 0) TP2 = TP("foo", 1) TP3 = TP("bar", 3) class TestFetcher: @pytest.fixture def consumer(self): return Mock( name="consumer", autospec=Consumer, _drain_messages=AsyncMock(), ) @pytest.fixture def fetcher(self, *, app, consumer):
def test_track_tp_end_offsets(self, *, mon): mon.track_tp_end_offset(TP('foo', 0), 4004) mon.client.gauge.assert_called_once_with( 'end_offset.foo.0', 4004, )
def _new_topicpartition(self, topic, partition) -> TP: return TP(topic, partition)
async def test_on_isolated_partition_revoked(self, *, actor): actor.cancel = Mock(name='cancel') actor.stop = AsyncMock(name='stop') await actor.on_isolated_partition_revoked(TP('foo', 0)) actor.cancel.assert_called_once_with() actor.stop.assert_called_once_with()
async def test_on_partitions_revoked(self, *, consumer): consumer._on_partitions_revoked = AsyncMock(name="opr") tps = {TP("foo", 0), TP("bar", 2)} await consumer.on_partitions_revoked(tps) consumer._on_partitions_revoked.assert_called_once_with(tps)
async def test_on_client_only_start(self, *, con, app): topic = app.topic('foo', 'bar') con.add(topic) await con.on_client_only_start() assert con._tp_index[TP(topic='foo', partition=0)] == {topic} assert con._tp_index[TP(topic='bar', partition=0)] == {topic}