implement lazy box test

dart/lib/src/sentry_trace_origins.dart

@@ -21,5 +21,6 @@ class SentryTraceOrigins {
 
   static const autoDbHive = 'auto.db.hive';
   static const autoDbHiveOpenDatabase = 'auto.db.hive.open_database';
-  static const autoDbHiveBaseBox = 'auto.db.hive.base_box';
+  static const autoDbHiveBoxBase = 'auto.db.hive.box_base';
+  static const autoDbHiveLazyBox = 'auto.db.hive.lazy_box';
 }

hive/lib/src/sentry_box.dart

@@ -29,7 +29,6 @@ class SentryBox<E> extends SentryBoxBase<E> implements Box<E> {
   }
 
   @override
-  // TODO: implement values
   Iterable<E> get values => _box.values;
 
   @override

hive/lib/src/sentry_box_base.dart

@@ -1,5 +1,6 @@
 
 import 'package:hive/hive.dart';
+import 'package:meta/meta.dart';
 import 'package:sentry/sentry.dart';
 import 'sentry_hive_impl.dart';
 
@@ -152,7 +153,7 @@ class SentryBoxBase<E> implements BoxBase<E> {
     );
 
     // ignore: invalid_use_of_internal_member
-    span?.origin = SentryTraceOrigins.autoDbHiveBaseBox;
+    span?.origin = SentryTraceOrigins.autoDbHiveBoxBase;
 
     span?.setData(SentryHiveImpl.dbSystemKey, SentryHiveImpl.dbSystem);
     span?.setData(SentryHiveImpl.dbNameKey, name);

hive/lib/src/sentry_lazy_box.dart

@@ -2,24 +2,60 @@
 import 'package:hive/hive.dart';
 import 'package:meta/meta.dart';
 import 'package:sentry/sentry.dart';
+import 'sentry_hive_impl.dart';
 
 import 'sentry_box_base.dart';
 
 ///
 class SentryLazyBox<E> extends SentryBoxBase<E> implements LazyBox<E> {
 
   final LazyBox<E> _lazyBox;
+  final Hub _hub;
 
   ///
-  SentryLazyBox(this._lazyBox, @internal Hub hub) : super(_lazyBox, hub);
+  SentryLazyBox(this._lazyBox, @internal this._hub) : super(_lazyBox, _hub);
 
   @override
   Future<E?> get(key, {E? defaultValue}) {
-    return _lazyBox.get(key, defaultValue: defaultValue);
+    return _asyncWrapInSpan('get', () async {
+      return await _lazyBox.get(key, defaultValue: defaultValue);
+    });
   }
 
   @override
   Future<E?> getAt(int index) {
-    return _lazyBox.getAt(index);
+    return _asyncWrapInSpan('getAt', () async {
+      return _lazyBox.getAt(index);
+    });
+  }
+
+  // Helper
+
+  Future<T> _asyncWrapInSpan<T>(String description, Future<T> Function() execute) async {
+    final currentSpan = _hub.getSpan();
+    final span = currentSpan?.startChild(
+      SentryHiveImpl.dbOp,
+      description: description,
+    );
+
+    // ignore: invalid_use_of_internal_member
+    span?.origin = SentryTraceOrigins.autoDbHiveLazyBox;
+
+    span?.setData(SentryHiveImpl.dbSystemKey, SentryHiveImpl.dbSystem);
+    span?.setData(SentryHiveImpl.dbNameKey, name);
+
+    try {
+      final result = await execute();
+      span?.status = SpanStatus.ok();
+
+      return result;
+    } catch (exception) {
+      span?.throwable = exception;
+      span?.status = SpanStatus.internalError();
+
+      rethrow;
+    } finally {
+      await span?.finish();
+    }
   }
 }

hive/test/person.dart

@@ -0,0 +1,24 @@
+import 'package:hive/hive.dart';
+
+@HiveType(typeId: 0)
+class Person extends HiveObject {
+  @HiveField(0)
+  final String name;
+
+  Person(this.name);
+}
+
+class PersonAdapter extends TypeAdapter<Person> {
+  @override
+  final typeId = 0;
+
+  @override
+  Person read(BinaryReader reader) {
+    return Person(reader.read() as String);
+  }
+
+  @override
+  void write(BinaryWriter writer, Person obj) {
+    writer.write(obj.name);
+  }
+}

hive/test/sentry_box_test.dart → hive/test/sentry_box_base_test.dart

@@ -5,12 +5,13 @@ import 'dart:io';
 import 'package:hive/hive.dart';
 import 'package:mockito/mockito.dart';
 import 'package:sentry/sentry.dart';
-import 'package:sentry_hive/sentry_hive.dart';
+import 'package:sentry_hive/src/sentry_box_base.dart';
 import 'package:sentry_hive/src/sentry_hive_impl.dart';
 import 'package:test/test.dart';
 import 'package:sentry/src/sentry_tracer.dart';
 
 import 'mocks/mocks.mocks.dart';
+import 'person.dart';
 
 void main() {
 
@@ -19,7 +20,7 @@ void main() {
     expect(span?.context.description, description);
     expect(span?.status, SpanStatus.ok());
     // ignore: invalid_use_of_internal_member
-    expect(span?.origin, SentryTraceOrigins.autoDbHiveBaseBox);
+    expect(span?.origin, SentryTraceOrigins.autoDbHiveBoxBase);
     expect(span?.data[SentryHiveImpl.dbSystemKey], SentryHiveImpl.dbSystem);
     expect(span?.data[SentryHiveImpl.dbNameKey], Fixture.dbName);
   }
@@ -107,28 +108,7 @@ void main() {
   });
 }
 
-@HiveType(typeId: 0)
-class Person extends HiveObject {
-  @HiveField(0)
-  final String name;
 
-  Person(this.name);
-}
-
-class PersonAdapter extends TypeAdapter<Person> {
-  @override
-  final typeId = 0;
-
-  @override
-  Person read(BinaryReader reader) {
-    return Person(reader.readString());
-  }
-
-  @override
-  void write(BinaryWriter writer, Person obj) {
-    writer.write(obj.name);
-  }
-}
 
 class Fixture {
   late final Box<Person> box;
@@ -141,8 +121,9 @@ class Fixture {
 
   Future<void> setUp() async {
     Hive.init(Directory.systemTemp.path);
-    Hive.registerAdapter(PersonAdapter());
-
+    if (!Hive.isAdapterRegistered(0)) {
+      Hive.registerAdapter(PersonAdapter());
+    }
     box = await Hive.openBox(dbName);
   }
 
@@ -153,8 +134,8 @@ class Fixture {
     }
   }
 
-  Future<SentryBox<Person>> getSut() async {
-    return SentryBox(box, hub);
+  Future<SentryBoxBase<Person>> getSut() async {
+    return SentryBoxBase(box, hub);
   }
 
   SentrySpan? getCreatedSpan() {

hive/test/sentry_lazy_box_test.dart

@@ -0,0 +1,94 @@
+@TestOn('vm')
+
+import 'dart:io';
+
+import 'package:hive/hive.dart';
+import 'package:mockito/mockito.dart';
+import 'package:sentry/sentry.dart';
+import 'package:sentry/src/sentry_tracer.dart';
+import 'package:sentry_hive/src/sentry_hive_impl.dart';
+import 'package:sentry_hive/src/sentry_lazy_box.dart';
+import 'package:test/test.dart';
+
+import 'mocks/mocks.mocks.dart';
+import 'person.dart';
+
+void main() {
+  void verifySpan(String description, SentrySpan? span) {
+    expect(span?.context.operation, SentryHiveImpl.dbOp);
+    expect(span?.context.description, description);
+    expect(span?.status, SpanStatus.ok());
+    // ignore: invalid_use_of_internal_member
+    expect(span?.origin, SentryTraceOrigins.autoDbHiveLazyBox);
+    expect(span?.data[SentryHiveImpl.dbSystemKey], SentryHiveImpl.dbSystem);
+    expect(span?.data[SentryHiveImpl.dbNameKey], Fixture.dbName);
+  }
+
+  group('adds span', () {
+
+    late Fixture fixture;
+
+    setUp(() async {
+      fixture = Fixture();
+      await fixture.setUp();
+
+      when(fixture.hub.options).thenReturn(fixture.options);
+      when(fixture.hub.getSpan()).thenReturn(fixture.tracer);
+    });
+
+    tearDown(() async {
+      await fixture.tearDown();
+    });
+
+    test('get adds span', () async {
+      final sut = await fixture.getSut();
+
+      await sut.put('fixture-key', Person('John Malkovich'));
+      await sut.get('fixture-key');
+
+      verifySpan('get', fixture.getCreatedSpan());
+    });
+
+    test('getAt adds span', () async {
+      final sut = await fixture.getSut();
+
+      await sut.add(Person('John Malkovich'));
+      await sut.getAt(0);
+
+      verifySpan('getAt', fixture.getCreatedSpan());
+    });
+  });
+}
+
+class Fixture {
+  late final LazyBox<Person> box;
+  final options = SentryOptions();
+  final hub = MockHub();
+  static final dbName = 'people';
+
+  final _context = SentryTransactionContext('name', 'operation');
+  late final tracer = SentryTracer(_context, hub);
+
+  Future<void> setUp() async {
+    Hive.init(Directory.systemTemp.path);
+    if (!Hive.isAdapterRegistered(0)) {
+      Hive.registerAdapter(PersonAdapter());
+    }
+    box = await Hive.openLazyBox(dbName);
+  }
+
+  Future<void> tearDown() async {
+    if (box.isOpen) {
+      await box.deleteFromDisk();
+      await box.close();
+    }
+  }
+
+  Future<SentryLazyBox<Person>> getSut() async {
+    return SentryLazyBox(box, hub);
+  }
+
+  SentrySpan? getCreatedSpan() {
+    return tracer.children.last;
+  }
+}