Add ComponentContainer tests for dependencies. (#3774)

* Add tests for container dependencies.

* Add Component Container tests for dependencies.

This ensures that no deadlocking occurs when fetching from the
container, and when a delete occurs.

Author: ryanwilson

Example/Core/Tests/FIRComponentContainerTest.m

@@ -17,6 +17,7 @@
 #import <FirebaseCore/FIRAppInternal.h>
 #import <FirebaseCore/FIRComponent.h>
 #import <FirebaseCore/FIRComponentContainerInternal.h>
+#import <FirebaseCore/FIROptions.h>
 
 #import "FIRTestComponents.h"
 
@@ -49,12 +50,19 @@ - (instancetype)initWithApp:(FIRApp *)app
 
 @end
 
-@interface FIRComponentContainerTest : FIRTestCase
+@interface FIRComponentContainerTest : FIRTestCase {
+  FIRApp *_hostApp;
+}
 
 @end
 
 @implementation FIRComponentContainerTest
 
+- (void)tearDown {
+  _hostApp = nil;
+  [super tearDown];
+}
+
 #pragma mark - Registration Tests
 
 - (void)testRegisteringConformingClass {
@@ -101,7 +109,8 @@ - (void)testInstanceNotCached {
 - (void)testRemoveAllCachedInstances {
   FIRComponentContainer *container =
       [self containerWithRegistrants:@ [[FIRTestClass class], [FIRTestClassCached class],
-                                        [FIRTestClassEagerCached class]]];
+                                        [FIRTestClassEagerCached class],
+                                        [FIRTestClassCachedWithDep class]]];
 
   // Retrieve an instance of FIRTestClassCached to ensure it's cached.
   id<FIRTestProtocolCached> cachedInstance1 = FIR_COMPONENT(FIRTestProtocolCached, container);
@@ -148,18 +157,57 @@ - (void)testProtocolAlreadyRegistered {
   XCTAssert(container.components.count == 1);
 }
 
+#pragma mark - Dependency Tests
+
+- (void)testDependencyDoesntBlock {
+  /// Test a class that has a dependency, and fetching doesn't block the internal queue.
+  FIRComponentContainer *container = [self
+      containerWithRegistrants:@ [[FIRTestClassCached class], [FIRTestClassCachedWithDep class]]];
+  XCTAssert(container.components.count == 2);
+
+  id<FIRTestProtocolCachedWithDep> instanceWithDep =
+      FIR_COMPONENT(FIRTestProtocolCachedWithDep, container);
+  XCTAssertNotNil(instanceWithDep);
+}
+
+- (void)testDependencyRemoveAllCachedInstancesDoesntBlock {
+  /// Test a class that has a dependency, and fetching doesn't block the internal queue.
+  FIRComponentContainer *container = [self
+      containerWithRegistrants:@ [[FIRTestClassCached class], [FIRTestClassCachedWithDep class]]];
+  XCTAssert(container.components.count == 2);
+
+  id<FIRTestProtocolCachedWithDep> instanceWithDep =
+      FIR_COMPONENT(FIRTestProtocolCachedWithDep, container);
+  XCTAssertNotNil(instanceWithDep);
+  XCTAssertNotNil(instanceWithDep.testProperty);
+
+  // Both `instanceWithDep` and `testProperty` should be cached now.
+  XCTAssertTrue(container.cachedInstances.count == 2);
+
+  // Remove the instances and verify cachedInstances is empty, and doesn't block the queue.
+  [container removeAllCachedInstances];
+  XCTAssertTrue(container.cachedInstances.count == 0);
+}
+
 #pragma mark - Convenience Methods
 
 /// Create a container that has registered the test class.
 - (FIRComponentContainer *)containerWithRegistrants:(NSArray<Class> *)registrants {
-  id appMock = OCMClassMock([FIRApp class]);
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:kGoogleAppID
+                                                    GCMSenderID:kGCMSenderID];
+  _hostApp = [[FIRApp alloc] initInstanceWithName:@"fake_app" options:options];
   NSMutableSet<Class> *allRegistrants = [NSMutableSet<Class> set];
 
   // Initialize the container with the test classes.
   for (Class c in registrants) {
     [FIRComponentContainer registerAsComponentRegistrant:c inSet:allRegistrants];
   }
-  return [[FIRComponentContainer alloc] initWithApp:appMock registrants:allRegistrants];
+
+  // Override the app's container with the newly instantiated container.
+  FIRComponentContainer *container = [[FIRComponentContainer alloc] initWithApp:_hostApp
+                                                                    registrants:allRegistrants];
+  _hostApp.container = container;
+  return container;
 }
 
 @end

Example/Core/Tests/FIRTestComponents.h

@@ -46,17 +46,33 @@
 /// A test class that is a component registrant that provides a component requiring eager
 /// instantiation, and is cached for easier validation that it was instantiated.
 @interface FIRTestClassEagerCached
-    : NSObject <FIRTestProtocol, FIRComponentLifecycleMaintainer, FIRLibrary>
+    : NSObject <FIRTestProtocolEagerCached, FIRComponentLifecycleMaintainer, FIRLibrary>
 @end
 
 #pragma mark - Cached Component
 
 /// A test protocol to be used for container testing.
 @protocol FIRTestProtocolCached
+- (void)cacheCow;
 @end
 
 /// A test class that is a component registrant that provides a component that requests to be
 /// cached.
 @interface FIRTestClassCached
-    : NSObject <FIRTestProtocol, FIRComponentLifecycleMaintainer, FIRLibrary>
+    : NSObject <FIRTestProtocolCached, FIRComponentLifecycleMaintainer, FIRLibrary>
+@end
+
+#pragma mark - Dependency on Standard
+
+/// A test protocol to be used for container testing.
+@protocol FIRTestProtocolCachedWithDep
+@property(nonatomic, strong) id<FIRTestProtocolCached> testProperty;
+@end
+
+/// A test class that is a component registrant that provides a component with a dependency on
+// `FIRTestProtocolCached`.
+@interface FIRTestClassCachedWithDep
+    : NSObject <FIRTestProtocolCachedWithDep, FIRComponentLifecycleMaintainer, FIRLibrary>
+@property(nonatomic, strong) id<FIRTestProtocolCached> testProperty;
+- (instancetype)initWithTest:(id<FIRTestProtocolCached>)testInstance;
 @end

Example/Core/Tests/FIRTestComponents.m

@@ -14,7 +14,9 @@
 
 #import "FIRTestComponents.h"
 
+#import <FirebaseCore/FIRAppInternal.h>
 #import <FirebaseCore/FIRComponent.h>
+#import <FirebaseCore/FIRDependency.h>
 
 #pragma mark - Standard Component
 
@@ -92,9 +94,6 @@ - (void)doSomethingFaster {
 - (void)appWillBeDeleted:(FIRApp *)app {
 }
 
-- (void)doSomething {
-}
-
 @end
 
 #pragma mark - Cached Component
@@ -118,7 +117,50 @@ @implementation FIRTestClassCached
 - (void)appWillBeDeleted:(FIRApp *)app {
 }
 
-- (void)doSomething {
+/// FIRTestProtocolCached conformance.
+- (void)cacheCow {
+}
+
+@end
+
+#pragma mark - Test Component with Dependency
+
+@implementation FIRTestClassCachedWithDep
+
+- (instancetype)initWithTest:(id<FIRTestProtocolCached>)testInstance {
+  self = [super init];
+  if (self != nil) {
+    self.testProperty = testInstance;
+  }
+  return self;
+}
+
+- (void)appWillBeDeleted:(nonnull FIRApp *)app {
+  // Do something that depends on the instance from our dependency.
+  [self.testProperty cacheCow];
+
+  // Fetch from the container in the deletion function.
+  id<FIRTestProtocolCached> anotherInstance = FIR_COMPONENT(FIRTestProtocolCached, app.container);
+  [anotherInstance cacheCow];
+}
+
++ (nonnull NSArray<FIRComponent *> *)componentsToRegister {
+  FIRDependency *dep = [FIRDependency dependencyWithProtocol:@protocol(FIRTestProtocolCached)];
+  FIRComponent *testComponent = [FIRComponent
+      componentWithProtocol:@protocol(FIRTestProtocolCachedWithDep)
+        instantiationTiming:FIRInstantiationTimingLazy
+               dependencies:@[ dep ]
+              creationBlock:^id _Nullable(FIRComponentContainer *_Nonnull container,
+                                          BOOL *_Nonnull isCacheable) {
+                // Fetch from the container in the instantiation block.
+                *isCacheable = YES;
+
+                id<FIRTestProtocolCached> test = FIR_COMPONENT(FIRTestProtocolCached, container);
+                FIRTestClassCachedWithDep *instance =
+                    [[FIRTestClassCachedWithDep alloc] initWithTest:test];
+                return instance;
+              }];
+  return @[ testComponent ];
 }
 
 @end