vjrj
beb29915d8
Match the inventory patterns the market was missing: - Search: OffersState gains a `query` + `visibleOffers` getter and OffersCubit.search() filters the already-discovered offers locally by summary (case-insensitive), never re-hitting the transport. The filter survives a refresh. Rounded search field mirrors inventory's. - Pull-to-refresh: RefreshIndicator re-runs discovery for the current area (empty state included, so a swipe re-scans). Text filter kept. - i18n: market.searchHint / market.noMatches (en/es/pt). Note: the shared slang output (strings*.g.dart, incl. the generated Asturian locale) is regenerated wholesale, so it also carries the in-progress `ast` locale keys already present in the working tree.
325 lines
10 KiB
Dart
325 lines
10 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:commons_core/commons_core.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:tane/data/variety_repository.dart';
|
|
import 'package:tane/db/enums.dart';
|
|
import 'package:tane/services/offer_mapper.dart';
|
|
import 'package:tane/services/offer_outbox.dart';
|
|
import 'package:tane/state/offers_cubit.dart';
|
|
|
|
import '../support/test_support.dart';
|
|
|
|
/// In-memory [OfferTransport] for tests: addressable by id, discover matches by
|
|
/// geohash prefix. No relay, no network.
|
|
class FakeOfferTransport implements OfferTransport {
|
|
final List<Offer> _offers = [];
|
|
|
|
@override
|
|
Future<PublishResult> publish(Offer offer) async {
|
|
_offers.removeWhere((o) => o.id == offer.id);
|
|
_offers.add(offer);
|
|
return PublishResult(accepted: true, transportRef: offer.id);
|
|
}
|
|
|
|
@override
|
|
Stream<Offer> discover(DiscoveryQuery query) {
|
|
final controller = StreamController<Offer>();
|
|
for (final o in _offers) {
|
|
if (o.approxGeohash.startsWith(query.geohashPrefix)) controller.add(o);
|
|
}
|
|
return controller.stream; // left open (live), like a real subscription
|
|
}
|
|
|
|
@override
|
|
Future<void> retract(String offerId) async =>
|
|
_offers.removeWhere((o) => o.id == offerId);
|
|
|
|
@override
|
|
Future<void> close() async {}
|
|
}
|
|
|
|
void main() {
|
|
group('OfferMapper', () {
|
|
test('maps local sharing intent to the network offer type', () {
|
|
expect(OfferMapper.offerTypeFor(OfferStatus.shared), OfferType.gift);
|
|
expect(OfferMapper.offerTypeFor(OfferStatus.exchange), OfferType.exchange);
|
|
expect(OfferMapper.offerTypeFor(OfferStatus.sell), OfferType.sale);
|
|
});
|
|
|
|
test('never publishes a private lot', () {
|
|
expect(() => OfferMapper.offerTypeFor(OfferStatus.private),
|
|
throwsArgumentError);
|
|
});
|
|
|
|
test('builds an offer, keeping price only for a sale', () {
|
|
final gift = OfferMapper.fromSharedLot(
|
|
lotId: 'lot-1',
|
|
authorPubkeyHex: 'ab' * 32,
|
|
summary: 'Tomate rosa',
|
|
sharing: OfferStatus.shared,
|
|
areaGeohash: 'sp3e9',
|
|
priceAmount: 5, // should be dropped for a gift
|
|
);
|
|
expect(gift.type, OfferType.gift);
|
|
expect(gift.id, 'lot-1');
|
|
expect(gift.priceAmount, isNull);
|
|
|
|
final sale = OfferMapper.fromSharedLot(
|
|
lotId: 'lot-2',
|
|
authorPubkeyHex: 'ab' * 32,
|
|
summary: 'Judía',
|
|
sharing: OfferStatus.sell,
|
|
areaGeohash: 'sp3e9',
|
|
priceAmount: 3,
|
|
priceCurrency: 'G1',
|
|
);
|
|
expect(sale.type, OfferType.sale);
|
|
expect(sale.priceAmount, 3);
|
|
expect(sale.priceCurrency, 'G1');
|
|
});
|
|
});
|
|
|
|
group('OffersCubit', () {
|
|
test('discovers published offers by geohash prefix', () async {
|
|
final transport = FakeOfferTransport();
|
|
await transport.publish(OfferMapper.fromSharedLot(
|
|
lotId: 'lot-1',
|
|
authorPubkeyHex: 'ab' * 32,
|
|
summary: 'Tomate rosa de Barbastro',
|
|
sharing: OfferStatus.shared,
|
|
areaGeohash: 'sp3e9',
|
|
));
|
|
final cubit = OffersCubit(transport);
|
|
|
|
await cubit.discover('sp3');
|
|
await pumpEventQueue();
|
|
|
|
expect(cubit.state.hasSearched, isTrue);
|
|
expect(cubit.state.searching, isFalse);
|
|
expect(cubit.state.offers, hasLength(1));
|
|
expect(cubit.state.offers.single.summary, 'Tomate rosa de Barbastro');
|
|
await cubit.close();
|
|
});
|
|
|
|
test('search narrows visible offers by summary, keeping the full list',
|
|
() async {
|
|
final transport = FakeOfferTransport();
|
|
for (final s in ['Tomate rosa', 'Judía verde', 'Tomate rojo']) {
|
|
await transport.publish(OfferMapper.fromSharedLot(
|
|
lotId: s,
|
|
authorPubkeyHex: 'ab' * 32,
|
|
summary: s,
|
|
sharing: OfferStatus.shared,
|
|
areaGeohash: 'sp3e9',
|
|
));
|
|
}
|
|
final cubit = OffersCubit(transport);
|
|
await cubit.discover('sp3');
|
|
await pumpEventQueue();
|
|
expect(cubit.state.offers, hasLength(3));
|
|
|
|
cubit.search('tomate'); // case-insensitive
|
|
expect(cubit.state.visibleOffers.map((o) => o.summary),
|
|
containsAll(['Tomate rosa', 'Tomate rojo']));
|
|
expect(cubit.state.visibleOffers, hasLength(2));
|
|
expect(cubit.state.offers, hasLength(3)); // underlying list untouched
|
|
|
|
cubit.search(''); // clearing shows everything again
|
|
expect(cubit.state.visibleOffers, hasLength(3));
|
|
await cubit.close();
|
|
});
|
|
|
|
test('the search filter survives a refresh (re-discovery)', () async {
|
|
final transport = FakeOfferTransport();
|
|
await transport.publish(OfferMapper.fromSharedLot(
|
|
lotId: 'lot-1',
|
|
authorPubkeyHex: 'ab' * 32,
|
|
summary: 'Pimiento',
|
|
sharing: OfferStatus.shared,
|
|
areaGeohash: 'sp3e9',
|
|
));
|
|
final cubit = OffersCubit(transport);
|
|
await cubit.discover('sp3');
|
|
await pumpEventQueue();
|
|
cubit.search('pim');
|
|
expect(cubit.state.query, 'pim');
|
|
|
|
await cubit.discover('sp3'); // pull-to-refresh
|
|
await pumpEventQueue();
|
|
expect(cubit.state.query, 'pim'); // kept across the refresh
|
|
expect(cubit.state.visibleOffers, hasLength(1));
|
|
await cubit.close();
|
|
});
|
|
|
|
test('a different area finds nothing', () async {
|
|
final transport = FakeOfferTransport();
|
|
await transport.publish(OfferMapper.fromSharedLot(
|
|
lotId: 'lot-1',
|
|
authorPubkeyHex: 'ab' * 32,
|
|
summary: 'Pimiento',
|
|
sharing: OfferStatus.shared,
|
|
areaGeohash: 'sp3e9',
|
|
));
|
|
final cubit = OffersCubit(transport);
|
|
await cubit.discover('u09');
|
|
await pumpEventQueue();
|
|
expect(cubit.state.offers, isEmpty);
|
|
await cubit.close();
|
|
});
|
|
|
|
test('publish reports the transport verdict', () async {
|
|
final cubit = OffersCubit(FakeOfferTransport());
|
|
final result = await cubit.publish(OfferMapper.fromSharedLot(
|
|
lotId: 'lot-9',
|
|
authorPubkeyHex: 'ab' * 32,
|
|
summary: 'Calabaza',
|
|
sharing: OfferStatus.exchange,
|
|
areaGeohash: 'sp3e9',
|
|
exchangeTerms: 'a cambio de legumbre',
|
|
));
|
|
expect(result.accepted, isTrue);
|
|
expect(cubit.state.publishing, isFalse);
|
|
await cubit.close();
|
|
});
|
|
|
|
test('publishLots publishes each shared lot and counts acceptances',
|
|
() async {
|
|
final transport = FakeOfferTransport();
|
|
final cubit = OffersCubit(transport);
|
|
final count = await cubit.publishLots(
|
|
const [
|
|
ShareableLot(
|
|
lotId: 'lot-1',
|
|
summary: 'Tomate',
|
|
offerStatus: OfferStatus.shared,
|
|
category: 'Solanaceae',
|
|
),
|
|
ShareableLot(
|
|
lotId: 'lot-2',
|
|
summary: 'Judía',
|
|
offerStatus: OfferStatus.exchange,
|
|
),
|
|
],
|
|
authorPubkeyHex: 'ab' * 32,
|
|
areaGeohash: 'sp3e9',
|
|
);
|
|
expect(count, 2);
|
|
expect(cubit.state.publishing, isFalse);
|
|
|
|
await cubit.discover('sp3');
|
|
await pumpEventQueue();
|
|
expect(cubit.state.offers, hasLength(2));
|
|
await cubit.close();
|
|
});
|
|
|
|
test('publishLots is a no-op offline or with no area', () async {
|
|
final offline = OffersCubit(null);
|
|
expect(
|
|
await offline.publishLots(
|
|
const [
|
|
ShareableLot(
|
|
lotId: 'x',
|
|
summary: 'x',
|
|
offerStatus: OfferStatus.shared,
|
|
),
|
|
],
|
|
authorPubkeyHex: 'ab' * 32,
|
|
areaGeohash: 'sp3e9',
|
|
),
|
|
0,
|
|
);
|
|
await offline.close();
|
|
|
|
final noArea = OffersCubit(FakeOfferTransport());
|
|
expect(
|
|
await noArea.publishLots(
|
|
const [
|
|
ShareableLot(
|
|
lotId: 'x',
|
|
summary: 'x',
|
|
offerStatus: OfferStatus.shared,
|
|
),
|
|
],
|
|
authorPubkeyHex: 'ab' * 32,
|
|
areaGeohash: '',
|
|
),
|
|
0,
|
|
);
|
|
await noArea.close();
|
|
});
|
|
|
|
test('flushOutbox publishes queued lots, then clears them', () async {
|
|
final outbox = OfferOutbox(InMemorySecretStore());
|
|
await outbox.enqueue(['lot-1', 'lot-2']);
|
|
final cubit = OffersCubit(FakeOfferTransport());
|
|
final count = await flushOutbox(
|
|
outbox: outbox,
|
|
cubit: cubit,
|
|
shareableLots: const [
|
|
ShareableLot(
|
|
lotId: 'lot-1', summary: 'Tomate', offerStatus: OfferStatus.shared),
|
|
ShareableLot(
|
|
lotId: 'lot-2',
|
|
summary: 'Judía',
|
|
offerStatus: OfferStatus.exchange),
|
|
ShareableLot(
|
|
lotId: 'lot-3', summary: 'Otro', offerStatus: OfferStatus.shared),
|
|
],
|
|
authorPubkeyHex: 'ab' * 32,
|
|
areaGeohash: 'sp3e9',
|
|
);
|
|
expect(count, 2);
|
|
expect(await outbox.pending(), isEmpty);
|
|
await cubit.close();
|
|
});
|
|
|
|
test('flushOutbox offline keeps the queue for later', () async {
|
|
final outbox = OfferOutbox(InMemorySecretStore());
|
|
await outbox.enqueue(['lot-1']);
|
|
final cubit = OffersCubit(null); // offline
|
|
final count = await flushOutbox(
|
|
outbox: outbox,
|
|
cubit: cubit,
|
|
shareableLots: const [],
|
|
authorPubkeyHex: 'ab' * 32,
|
|
areaGeohash: 'sp3e9',
|
|
);
|
|
expect(count, 0);
|
|
expect(await outbox.pending(), {'lot-1'});
|
|
await cubit.close();
|
|
});
|
|
|
|
test('flushOutbox drops queued lots that no longer exist', () async {
|
|
final outbox = OfferOutbox(InMemorySecretStore());
|
|
await outbox.enqueue(['gone']);
|
|
final cubit = OffersCubit(FakeOfferTransport());
|
|
final count = await flushOutbox(
|
|
outbox: outbox,
|
|
cubit: cubit,
|
|
shareableLots: const [],
|
|
authorPubkeyHex: 'ab' * 32,
|
|
areaGeohash: 'sp3e9',
|
|
);
|
|
expect(count, 0);
|
|
expect(await outbox.pending(), isEmpty);
|
|
await cubit.close();
|
|
});
|
|
|
|
test('offline (no transport): degrades gracefully, never throws', () async {
|
|
final cubit = OffersCubit(null);
|
|
expect(cubit.isOnline, isFalse);
|
|
await cubit.discover('sp3');
|
|
expect(cubit.state.error, 'offline');
|
|
final result = await cubit.publish(OfferMapper.fromSharedLot(
|
|
lotId: 'x',
|
|
authorPubkeyHex: 'ab' * 32,
|
|
summary: 'x',
|
|
sharing: OfferStatus.shared,
|
|
areaGeohash: 'sp3e9',
|
|
));
|
|
expect(result.accepted, isFalse);
|
|
await cubit.close();
|
|
});
|
|
});
|
|
}
|