mirror of
https://github.com/firebase/firebase-ios-sdk
synced 2026-11-09 22:36:01 +05:45
1099 lines
53 KiB
Objective-C
1099 lines
53 KiB
Objective-C
/*
|
|
* Copyright 2019 Google
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#import <OCMock/OCMock.h>
|
|
#import <XCTest/XCTest.h>
|
|
|
|
#import "FirebaseRemoteConfig/Sources/Private/RCNConfigSettings.h"
|
|
#import "FirebaseRemoteConfig/Sources/Public/FirebaseRemoteConfig/FIRRemoteConfig.h"
|
|
#import "FirebaseRemoteConfig/Sources/RCNConfigConstants.h"
|
|
#import "FirebaseRemoteConfig/Sources/RCNConfigContent.h"
|
|
#import "FirebaseRemoteConfig/Sources/RCNConfigDBManager.h"
|
|
#import "FirebaseRemoteConfig/Sources/RCNConfigValue_Internal.h"
|
|
#import "FirebaseRemoteConfig/Tests/Unit/RCNTestUtilities.h"
|
|
@import FirebaseRemoteConfigInterop;
|
|
|
|
@interface RCNConfigContent (Testing)
|
|
- (NSMutableSet<NSString *> *)
|
|
getKeysAffectedByChangedExperiments:(NSMutableArray *)activeExperimentPayloads
|
|
fetchedExperimentPayloads:(NSMutableArray *)experimentPayloads;
|
|
- (BOOL)checkAndWaitForInitialDatabaseLoad;
|
|
@end
|
|
|
|
extern const NSTimeInterval kDatabaseLoadTimeoutSecs;
|
|
@interface RCNConfigDBManagerMock : RCNConfigDBManager
|
|
@property(nonatomic, assign) BOOL isLoadMainCompleted;
|
|
@property(nonatomic, assign) BOOL isLoadPersonalizationCompleted;
|
|
@end
|
|
@implementation RCNConfigDBManagerMock
|
|
- (void)createOrOpenDatabase {
|
|
}
|
|
- (void)loadMainWithBundleIdentifier:(NSString *)bundleIdentifier
|
|
completionHandler:(RCNDBLoadCompletion)handler {
|
|
double justSmallDelay = 0.008;
|
|
XCTAssertTrue(justSmallDelay < kDatabaseLoadTimeoutSecs);
|
|
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(justSmallDelay * NSEC_PER_SEC)),
|
|
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
self.isLoadMainCompleted = YES;
|
|
handler(YES, nil, nil, nil, nil);
|
|
});
|
|
}
|
|
- (void)loadPersonalizationWithCompletionHandler:(RCNDBLoadCompletion)handler {
|
|
double justOtherSmallDelay = 0.009;
|
|
XCTAssertTrue(justOtherSmallDelay < kDatabaseLoadTimeoutSecs);
|
|
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(justOtherSmallDelay * NSEC_PER_SEC)),
|
|
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
self.isLoadPersonalizationCompleted = YES;
|
|
handler(YES, nil, nil, nil, nil);
|
|
});
|
|
}
|
|
@end
|
|
|
|
@interface RCNConfigContentTest : XCTestCase {
|
|
NSTimeInterval _expectationTimeout;
|
|
RCNConfigContent *_configContent;
|
|
NSString *namespaceApp1, *namespaceApp2;
|
|
NSString *_namespaceGoogleMobilePlatform;
|
|
}
|
|
@end
|
|
|
|
/// Unit Tests for RCNConfigContent methods.
|
|
@implementation RCNConfigContentTest
|
|
- (void)setUp {
|
|
[super setUp];
|
|
_expectationTimeout = 1.0;
|
|
_namespaceGoogleMobilePlatform = FIRRemoteConfigConstants.FIRNamespaceGoogleMobilePlatform;
|
|
|
|
namespaceApp1 = [NSString
|
|
stringWithFormat:@"%@:%@", _namespaceGoogleMobilePlatform, RCNTestsDefaultFIRAppName];
|
|
namespaceApp2 = [NSString
|
|
stringWithFormat:@"%@:%@", _namespaceGoogleMobilePlatform, RCNTestsSecondFIRAppName];
|
|
|
|
_configContent = [[RCNConfigContent alloc] initWithDBManager:nil];
|
|
|
|
id partialMock = OCMPartialMock(_configContent);
|
|
OCMStub([partialMock checkAndWaitForInitialDatabaseLoad]).andDo(nil);
|
|
}
|
|
|
|
/// Passing in a nil bundleID should not crash the app
|
|
- (void)testCrashShouldNotHappenWithoutMainBundleID {
|
|
id mockBundle = OCMPartialMock([NSBundle mainBundle]);
|
|
OCMStub([mockBundle bundleIdentifier]).andReturn(nil);
|
|
_configContent = [[RCNConfigContent alloc] initWithDBManager:nil];
|
|
[mockBundle stopMocking];
|
|
}
|
|
|
|
/// Standard test case of receiving updated config from fetch.
|
|
- (void)testUpdateConfigContentForMultipleApps {
|
|
NSMutableDictionary<NSString *, id> *config1ToSet =
|
|
[[NSMutableDictionary alloc] initWithObjectsAndKeys:@"UPDATE", @"state", nil];
|
|
NSDictionary<NSString *, NSString *> *entries = @{@"key1" : @"value1", @"key2" : @"value2"};
|
|
[config1ToSet setValue:entries forKey:@"entries"];
|
|
[_configContent updateConfigContentWithResponse:config1ToSet forNamespace:namespaceApp1];
|
|
|
|
// Update for second app.
|
|
NSMutableDictionary<NSString *, id> *config2ToSet =
|
|
[[NSMutableDictionary alloc] initWithObjectsAndKeys:@"UPDATE", @"state", nil];
|
|
NSDictionary<NSString *, NSString *> *entries2 = @{@"key11" : @"value11", @"key21" : @"value21"};
|
|
[config2ToSet setValue:entries2 forKey:@"entries"];
|
|
[_configContent updateConfigContentWithResponse:config2ToSet forNamespace:namespaceApp2];
|
|
|
|
// Check config for first app.
|
|
|
|
NSDictionary *fetchedConfig = _configContent.fetchedConfig;
|
|
XCTAssertNotNil(fetchedConfig[namespaceApp1][@"key1"]);
|
|
XCTAssertEqualObjects([fetchedConfig[namespaceApp1][@"key1"] stringValue], @"value1");
|
|
XCTAssertNotNil(fetchedConfig[namespaceApp1][@"key2"]);
|
|
XCTAssertEqualObjects([fetchedConfig[namespaceApp1][@"key2"] stringValue], @"value2");
|
|
|
|
// Check config for second app.
|
|
|
|
fetchedConfig = _configContent.fetchedConfig;
|
|
XCTAssertNotNil(fetchedConfig[namespaceApp2][@"key11"]);
|
|
XCTAssertEqualObjects([fetchedConfig[namespaceApp2][@"key11"] stringValue], @"value11");
|
|
XCTAssertNotNil(fetchedConfig[namespaceApp2][@"key21"]);
|
|
XCTAssertEqualObjects([fetchedConfig[namespaceApp2][@"key21"] stringValue], @"value21");
|
|
}
|
|
|
|
/// Standard test case of receiving updated config from fetch.
|
|
- (void)testUpdateConfigContentWithResponse {
|
|
NSMutableDictionary *configToSet =
|
|
[[NSMutableDictionary alloc] initWithObjectsAndKeys:@"UPDATE", @"state", nil];
|
|
NSDictionary *entries = @{@"key1" : @"value1", @"key2" : @"value2"};
|
|
[configToSet setValue:entries forKey:@"entries"];
|
|
[_configContent updateConfigContentWithResponse:configToSet
|
|
forNamespace:_namespaceGoogleMobilePlatform];
|
|
|
|
NSDictionary *fetchedConfig = _configContent.fetchedConfig;
|
|
XCTAssertNotNil(fetchedConfig[_namespaceGoogleMobilePlatform][@"key1"]);
|
|
XCTAssertEqualObjects([fetchedConfig[_namespaceGoogleMobilePlatform][@"key1"] stringValue],
|
|
@"value1");
|
|
XCTAssertNotNil(fetchedConfig[_namespaceGoogleMobilePlatform][@"key2"]);
|
|
XCTAssertEqualObjects([fetchedConfig[_namespaceGoogleMobilePlatform][@"key2"] stringValue],
|
|
@"value2");
|
|
}
|
|
|
|
/// A fetch response whose nested fields have unexpected JSON types must not crash the parser.
|
|
- (void)testUpdateConfigContentWithMalformedResponseDoesNotCrash {
|
|
// Non-string `state` must not reach -isEqualToString:.
|
|
[_configContent updateConfigContentWithResponse:@{@"state" : @5}
|
|
forNamespace:_namespaceGoogleMobilePlatform];
|
|
|
|
// state == UPDATE with a non-dictionary `entries` must not be fast-enumerated.
|
|
[_configContent
|
|
updateConfigContentWithResponse:@{@"state" : @"UPDATE", @"entries" : @"not-a-dict"}
|
|
forNamespace:_namespaceGoogleMobilePlatform];
|
|
|
|
// A non-string entry value must not reach -dataUsingEncoding:.
|
|
[_configContent
|
|
updateConfigContentWithResponse:@{@"state" : @"UPDATE", @"entries" : @{@"key1" : @7}}
|
|
forNamespace:_namespaceGoogleMobilePlatform];
|
|
|
|
// A well-formed value alongside a bad one is still stored.
|
|
[_configContent updateConfigContentWithResponse:@{
|
|
@"state" : @"UPDATE",
|
|
@"entries" : @{@"key1" : @7, @"key2" : @"value2"}
|
|
}
|
|
forNamespace:_namespaceGoogleMobilePlatform];
|
|
NSDictionary *fetchedConfig = _configContent.fetchedConfig;
|
|
XCTAssertNil(fetchedConfig[_namespaceGoogleMobilePlatform][@"key1"]);
|
|
XCTAssertEqualObjects([fetchedConfig[_namespaceGoogleMobilePlatform][@"key2"] stringValue],
|
|
@"value2");
|
|
|
|
// A non-dictionary `entries` drops the update and keeps the previously fetched values.
|
|
[_configContent
|
|
updateConfigContentWithResponse:@{@"state" : @"UPDATE", @"entries" : @"not-a-dict"}
|
|
forNamespace:_namespaceGoogleMobilePlatform];
|
|
fetchedConfig = _configContent.fetchedConfig;
|
|
XCTAssertEqualObjects([fetchedConfig[_namespaceGoogleMobilePlatform][@"key2"] stringValue],
|
|
@"value2");
|
|
}
|
|
|
|
/// An `UPDATE` response without `entries` is a valid empty config and clears the previously
|
|
/// fetched values.
|
|
- (void)testUpdateConfigContentWithUpdateStateAndNoEntriesClearsFetchedConfig {
|
|
[_configContent
|
|
updateConfigContentWithResponse:@{@"state" : @"UPDATE", @"entries" : @{@"key1" : @"value1"}}
|
|
forNamespace:_namespaceGoogleMobilePlatform];
|
|
XCTAssertNotNil(_configContent.fetchedConfig[_namespaceGoogleMobilePlatform][@"key1"]);
|
|
|
|
[_configContent updateConfigContentWithResponse:@{@"state" : @"UPDATE"}
|
|
forNamespace:_namespaceGoogleMobilePlatform];
|
|
NSDictionary *fetchedConfig = _configContent.fetchedConfig;
|
|
XCTAssertNotNil(fetchedConfig[_namespaceGoogleMobilePlatform]);
|
|
XCTAssertEqual(((NSDictionary *)fetchedConfig[_namespaceGoogleMobilePlatform]).count, 0);
|
|
}
|
|
|
|
/// Verify that fetchedConfig is overwritten for a new fetch call.
|
|
- (void)testUpdateConfigContentWithStatusUpdateWithDifferentKeys {
|
|
NSMutableDictionary *configToSet =
|
|
[[NSMutableDictionary alloc] initWithObjectsAndKeys:@"UPDATE", @"state", nil];
|
|
NSDictionary *entries = @{@"key1" : @"value1"};
|
|
[configToSet setValue:entries forKey:@"entries"];
|
|
[_configContent updateConfigContentWithResponse:configToSet
|
|
forNamespace:_namespaceGoogleMobilePlatform];
|
|
configToSet = [[NSMutableDictionary alloc] initWithObjectsAndKeys:@"UPDATE", @"state", nil];
|
|
entries = @{@"key2" : @"value2", @"key3" : @"value3"};
|
|
[configToSet setValue:entries forKey:@"entries"];
|
|
[_configContent updateConfigContentWithResponse:configToSet
|
|
forNamespace:_namespaceGoogleMobilePlatform];
|
|
|
|
NSDictionary *fetchedConfig = _configContent.fetchedConfig;
|
|
XCTAssertNil(fetchedConfig[_namespaceGoogleMobilePlatform][@"key1"]);
|
|
XCTAssertNotNil(fetchedConfig[_namespaceGoogleMobilePlatform][@"key2"]);
|
|
XCTAssertEqualObjects([fetchedConfig[_namespaceGoogleMobilePlatform][@"key2"] stringValue],
|
|
@"value2");
|
|
XCTAssertNotNil(fetchedConfig[_namespaceGoogleMobilePlatform][@"key3"]);
|
|
XCTAssertEqualObjects([fetchedConfig[_namespaceGoogleMobilePlatform][@"key3"] stringValue],
|
|
@"value3");
|
|
}
|
|
|
|
/// Verify fetchedConfig is available across different namespaces.
|
|
- (void)testUpdateConfigContentWithStatusUpdateWithDifferentNamespaces {
|
|
NSMutableDictionary *configToSet =
|
|
[[NSMutableDictionary alloc] initWithObjectsAndKeys:@"UPDATE", @"state", nil];
|
|
NSMutableDictionary *configToSet2 =
|
|
[[NSMutableDictionary alloc] initWithObjectsAndKeys:@"UPDATE", @"state", nil];
|
|
NSDictionary *entries = @{@"key1" : @"value1"};
|
|
NSDictionary *entries2 = @{@"key2" : @"value2"};
|
|
[configToSet setValue:entries forKey:@"entries"];
|
|
[configToSet2 setValue:entries2 forKey:@"entries"];
|
|
[_configContent updateConfigContentWithResponse:configToSet forNamespace:@"namespace_1"];
|
|
[_configContent updateConfigContentWithResponse:configToSet2 forNamespace:@"namespace_2"];
|
|
[_configContent updateConfigContentWithResponse:configToSet forNamespace:@"namespace_3"];
|
|
[_configContent updateConfigContentWithResponse:configToSet2 forNamespace:@"namespace_4"];
|
|
|
|
NSDictionary *fetchedConfig = _configContent.fetchedConfig;
|
|
|
|
XCTAssertNotNil(fetchedConfig[@"namespace_1"][@"key1"]);
|
|
XCTAssertEqualObjects([fetchedConfig[@"namespace_1"][@"key1"] stringValue], @"value1");
|
|
XCTAssertNotNil(fetchedConfig[@"namespace_2"][@"key2"]);
|
|
XCTAssertEqualObjects([fetchedConfig[@"namespace_2"][@"key2"] stringValue], @"value2");
|
|
XCTAssertNotNil(fetchedConfig[@"namespace_3"][@"key1"]);
|
|
XCTAssertEqualObjects([fetchedConfig[@"namespace_3"][@"key1"] stringValue], @"value1");
|
|
XCTAssertNotNil(fetchedConfig[@"namespace_4"][@"key2"]);
|
|
XCTAssertEqualObjects([fetchedConfig[@"namespace_4"][@"key2"] stringValue], @"value2");
|
|
}
|
|
|
|
- (void)skip_testUpdateConfigContentWithStatusNoChange {
|
|
// TODO: Add test case once new eTag based logic is implemented.
|
|
}
|
|
|
|
- (void)skip_testUpdateConfigContentWithRemoveNamespaceStatus {
|
|
// TODO: Add test case once new eTag based logic is implemented.
|
|
}
|
|
|
|
- (void)skip_testUpdateConfigContentWithEmptyConfig {
|
|
// TODO: Add test case once new eTag based logic is implemented.
|
|
}
|
|
|
|
- (void)testCopyFromDictionaryDoesNotUpdateFetchedConfig {
|
|
NSMutableDictionary *configToSet =
|
|
[[NSMutableDictionary alloc] initWithObjectsAndKeys:@"UPDATE", @"state", nil];
|
|
NSDictionary *entries = @{@"key1" : @"value1", @"key2" : @"value2"};
|
|
[configToSet setValue:entries forKey:@"entries"];
|
|
[_configContent updateConfigContentWithResponse:configToSet forNamespace:@"dummy_namespace"];
|
|
NSDictionary *namespaceToConfig = @{
|
|
@"dummy_namespace" : @{
|
|
@"new_key" : @"new_value",
|
|
|
|
}
|
|
};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceFetched
|
|
forNamespace:@"dummy_namespace"];
|
|
XCTAssertEqual(((NSDictionary *)_configContent.fetchedConfig[@"dummy_namespace"]).count, 2);
|
|
XCTAssertEqual(_configContent.activeConfig.count, 0);
|
|
XCTAssertEqual(_configContent.defaultConfig.count, 0);
|
|
}
|
|
|
|
- (void)testCopyFromDictionaryUpdatesDefaultConfig {
|
|
NSDictionary *embeddedDictionary = @{@"default_embedded_key" : @"default_embedded_Value"};
|
|
NSData *dataValue = [NSJSONSerialization dataWithJSONObject:embeddedDictionary
|
|
options:NSJSONWritingPrettyPrinted
|
|
error:nil];
|
|
NSDate *now = [NSDate date];
|
|
NSError *error;
|
|
NSData *JSONData = [NSJSONSerialization dataWithJSONObject:@{@"key1" : @"value1"}
|
|
options:0
|
|
error:&error];
|
|
NSString *JSONString = [[NSString alloc] initWithData:JSONData encoding:NSUTF8StringEncoding];
|
|
NSDictionary *namespaceToConfig = @{
|
|
@"default_namespace" : @{
|
|
@"new_string_key" : @"new_string_value",
|
|
@"new_number_key" : @1234,
|
|
@"new_data_key" : dataValue,
|
|
@"new_date_key" : now,
|
|
@"new_json_key" : JSONString
|
|
}
|
|
};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceDefault
|
|
forNamespace:@"default_namespace"];
|
|
NSDictionary *defaultConfig = _configContent.defaultConfig;
|
|
XCTAssertEqual(_configContent.fetchedConfig.count, 0);
|
|
XCTAssertEqual(_configContent.activeConfig.count, 0);
|
|
XCTAssertNotNil(defaultConfig[@"default_namespace"]);
|
|
XCTAssertEqual(((NSDictionary *)defaultConfig[@"default_namespace"]).count, 5);
|
|
XCTAssertEqualObjects(@"new_string_value",
|
|
[defaultConfig[@"default_namespace"][@"new_string_key"] stringValue]);
|
|
XCTAssertEqualObjects(
|
|
@1234, [((FIRRemoteConfigValue *)defaultConfig[@"default_namespace"][@"new_number_key"])
|
|
numberValue]);
|
|
NSDictionary<NSString *, NSString *> *sampleJSON = @{@"key1" : @"value1"};
|
|
id configJSON = [(defaultConfig[@"default_namespace"][@"new_json_key"]) JSONValue];
|
|
XCTAssertTrue([configJSON isKindOfClass:[NSDictionary class]]);
|
|
XCTAssertTrue([sampleJSON isKindOfClass:[NSDictionary class]]);
|
|
XCTAssertEqualObjects(sampleJSON, (NSDictionary *)configJSON);
|
|
XCTAssertEqualObjects(dataValue,
|
|
[defaultConfig[@"default_namespace"][@"new_data_key"] dataValue]);
|
|
NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
|
|
[dateFormatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"];
|
|
NSString *strValueForDate = [dateFormatter stringFromDate:now];
|
|
XCTAssertEqualObjects(strValueForDate,
|
|
[defaultConfig[@"default_namespace"][@"new_date_key"] stringValue]);
|
|
}
|
|
|
|
/// Array and dictionary defaults that can't be serialized as JSON are skipped instead of raising.
|
|
- (void)testCopyFromDictionarySkipsDefaultsThatAreNotValidJSON {
|
|
NSData *data = [@"value1" dataUsingEncoding:NSUTF8StringEncoding];
|
|
NSDictionary *namespaceToConfig = @{
|
|
@"default_namespace" : @{
|
|
@"string_key" : @"string_value",
|
|
@"array_key" : @[ @"value1", @2 ],
|
|
@"dictionary_key" : @{@"key1" : @"value1"},
|
|
@"array_with_date_key" : @[ [NSDate date] ],
|
|
@"dictionary_with_data_key" : @{@"key1" : data},
|
|
}
|
|
};
|
|
XCTAssertNoThrow([_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceDefault
|
|
forNamespace:@"default_namespace"]);
|
|
|
|
NSDictionary *defaultConfig = _configContent.defaultConfig[@"default_namespace"];
|
|
XCTAssertEqual(defaultConfig.count, 3);
|
|
XCTAssertEqualObjects([defaultConfig[@"string_key"] stringValue], @"string_value");
|
|
XCTAssertEqualObjects([defaultConfig[@"array_key"] JSONValue], (@[ @"value1", @2 ]));
|
|
XCTAssertEqualObjects([defaultConfig[@"dictionary_key"] JSONValue], @{@"key1" : @"value1"});
|
|
XCTAssertNil(defaultConfig[@"array_with_date_key"]);
|
|
XCTAssertNil(defaultConfig[@"dictionary_with_data_key"]);
|
|
}
|
|
|
|
- (void)testCopyFromDictionaryUpdatesActiveConfig {
|
|
// Active config values must be RCNConfigValue format
|
|
NSDictionary *embeddedDictionary = @{@"active_embedded_key" : @"active_embedded_Value"};
|
|
NSData *dataValue = [NSJSONSerialization dataWithJSONObject:embeddedDictionary
|
|
options:NSJSONWritingPrettyPrinted
|
|
error:nil];
|
|
|
|
NSDictionary *namespaceToConfig = @{
|
|
@"dummy_namespace" : @{
|
|
@"new_key" : [[FIRRemoteConfigValue alloc] initWithData:dataValue source:-1],
|
|
}
|
|
};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceActive
|
|
forNamespace:@"dummy_namespace"];
|
|
XCTAssertEqual(((NSDictionary *)_configContent.activeConfig[@"dummy_namespace"]).count, 1);
|
|
XCTAssertEqual(_configContent.fetchedConfig.count, 0);
|
|
XCTAssertEqual(_configContent.defaultConfig.count, 0);
|
|
XCTAssertEqualObjects(dataValue,
|
|
[_configContent.activeConfig[@"dummy_namespace"][@"new_key"] dataValue]);
|
|
}
|
|
|
|
- (void)testCheckAndWaitForInitialDatabaseLoad {
|
|
RCNConfigDBManagerMock *mockDBManager = [[RCNConfigDBManagerMock alloc] init];
|
|
RCNConfigContent *configContent = [[RCNConfigContent alloc] initWithDBManager:mockDBManager];
|
|
|
|
// Check that no one of first three calls of `-checkAndWaitForInitialDatabaseLoad` do not produce
|
|
// timeout error <begin>
|
|
XCTestExpectation *expectation1 =
|
|
[self expectationWithDescription:
|
|
@"1st `checkAndWaitForInitialDatabaseLoad` return without timeout"];
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
XCTAssertTrue([configContent checkAndWaitForInitialDatabaseLoad]);
|
|
[expectation1 fulfill];
|
|
});
|
|
XCTestExpectation *expectation2 =
|
|
[self expectationWithDescription:
|
|
@"2nd `checkAndWaitForInitialDatabaseLoad` return without timeout"];
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
XCTAssertTrue([configContent checkAndWaitForInitialDatabaseLoad]);
|
|
[expectation2 fulfill];
|
|
});
|
|
|
|
XCTAssertTrue([configContent checkAndWaitForInitialDatabaseLoad]);
|
|
// Check that both `-load...` methods already completed after 1st wait.
|
|
// This make us sure that both `-loadMainWithBundleIdentifier` and
|
|
// `-loadPersonalizationWithCompletionHandler` methods synched with
|
|
// `-checkAndWaitForInitialDatabaseLoad`.
|
|
XCTAssertTrue(mockDBManager.isLoadMainCompleted);
|
|
XCTAssertTrue(mockDBManager.isLoadPersonalizationCompleted);
|
|
|
|
// Check that no one of first three calls of `-checkAndWaitForInitialDatabaseLoad` do not produce
|
|
// timeout error <end>.
|
|
// This make us sure that there no threads "stuck" on `-checkAndWaitForInitialDatabaseLoad`.
|
|
[self waitForExpectationsWithTimeout:0.5 * kDatabaseLoadTimeoutSecs handler:nil];
|
|
}
|
|
|
|
- (void)testConfigUpdate_noChange_emptyResponse {
|
|
NSString *namespace = @"test_namespace";
|
|
|
|
// populate fetched config
|
|
NSMutableDictionary *fetchResponse =
|
|
[self createFetchResponseWithConfigEntries:@{@"key1" : @"value1"}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:nil];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
// active config to match fetched config
|
|
FIRRemoteConfigValue *value =
|
|
[[FIRRemoteConfigValue alloc] initWithData:[@"value1" dataUsingEncoding:NSUTF8StringEncoding]
|
|
source:FIRRemoteConfigSourceRemote];
|
|
NSDictionary *namespaceToConfig = @{namespace : @{@"key1" : value}};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceActive
|
|
forNamespace:namespace];
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:@"Config update completion"];
|
|
|
|
[_configContent getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertNotNil(update, @"Update object should not be nil");
|
|
XCTAssertEqual(update.updatedKeys.count, 0,
|
|
@"There should be no updated keys when configs match");
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testConfigUpdate_noParamChange_butExperimentChange {
|
|
NSString *namespace = @"test_namespace";
|
|
RCNConfigContent *configContent = [[RCNConfigContent alloc] initWithDBManager:nil];
|
|
NSMutableSet<NSString *> *experimentKeys = [[NSMutableSet alloc] init];
|
|
[experimentKeys addObject:@"key_2"];
|
|
id configMock = OCMPartialMock(configContent);
|
|
OCMStub([configMock getKeysAffectedByChangedExperiments:OCMOCK_ANY
|
|
fetchedExperimentPayloads:OCMOCK_ANY])
|
|
.andReturn(experimentKeys);
|
|
|
|
// populate fetched config
|
|
NSMutableDictionary *fetchResponse =
|
|
[self createFetchResponseWithConfigEntries:@{@"key1" : @"value1"}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:nil];
|
|
[configMock updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
// active config is the same as fetched config
|
|
FIRRemoteConfigValue *value =
|
|
[[FIRRemoteConfigValue alloc] initWithData:[@"value1" dataUsingEncoding:NSUTF8StringEncoding]
|
|
source:FIRRemoteConfigSourceRemote];
|
|
NSDictionary *namespaceToConfig = @{namespace : @{@"key1" : value}};
|
|
[configMock copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceActive
|
|
forNamespace:namespace];
|
|
|
|
// Create expectation for async callback
|
|
XCTestExpectation *expectation = [self expectationWithDescription:@"Config update completion"];
|
|
|
|
[configMock getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertTrue([update updatedKeys].count == 1);
|
|
XCTAssertTrue([[update updatedKeys] containsObject:@"key_2"]);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testExperimentDiff_addedExperiment {
|
|
NSData *payloadData1 = [[self class] payloadDataFromTestFile];
|
|
NSMutableArray *activeExperimentPayloads = [@[ payloadData1 ] mutableCopy];
|
|
|
|
NSError *dataError;
|
|
NSMutableDictionary *payload =
|
|
[NSJSONSerialization JSONObjectWithData:payloadData1
|
|
options:NSJSONReadingMutableContainers
|
|
error:&dataError];
|
|
[payload setValue:@"exp_2" forKey:@"experimentId"];
|
|
NSError *jsonError;
|
|
NSData *payloadData2 = [NSJSONSerialization dataWithJSONObject:payload
|
|
options:kNilOptions
|
|
error:&jsonError];
|
|
NSMutableArray *experimentPayloads = [@[ payloadData1, payloadData2 ] mutableCopy];
|
|
|
|
RCNConfigContent *configContent = [[RCNConfigContent alloc] initWithDBManager:nil];
|
|
NSMutableSet<NSString *> *changedKeys =
|
|
[configContent getKeysAffectedByChangedExperiments:activeExperimentPayloads
|
|
fetchedExperimentPayloads:experimentPayloads];
|
|
XCTAssertTrue([changedKeys containsObject:@"test_key_1"]);
|
|
}
|
|
|
|
- (void)testExperimentDiff_changedExperimentMetadata {
|
|
NSData *payloadData1 = [[self class] payloadDataFromTestFile];
|
|
NSMutableArray *activeExperimentPayloads = [@[ payloadData1 ] mutableCopy];
|
|
|
|
NSError *dataError;
|
|
NSMutableDictionary *payload =
|
|
[NSJSONSerialization JSONObjectWithData:payloadData1
|
|
options:NSJSONReadingMutableContainers
|
|
error:&dataError];
|
|
[payload setValue:@"var_2" forKey:@"variantId"];
|
|
NSError *jsonError;
|
|
NSData *payloadData2 = [NSJSONSerialization dataWithJSONObject:payload
|
|
options:kNilOptions
|
|
error:&jsonError];
|
|
NSMutableArray *experimentPayloads = [@[ payloadData1, payloadData2 ] mutableCopy];
|
|
|
|
RCNConfigContent *configContent = [[RCNConfigContent alloc] initWithDBManager:nil];
|
|
NSMutableSet<NSString *> *changedKeys =
|
|
[configContent getKeysAffectedByChangedExperiments:activeExperimentPayloads
|
|
fetchedExperimentPayloads:experimentPayloads];
|
|
XCTAssertTrue([changedKeys containsObject:@"test_key_1"]);
|
|
}
|
|
|
|
- (void)testExperimentDiff_changedExperimentKeys {
|
|
NSData *payloadData1 = [[self class] payloadDataFromTestFile];
|
|
NSMutableArray *activeExperimentPayloads = [@[ payloadData1 ] mutableCopy];
|
|
|
|
NSError *dataError;
|
|
NSMutableDictionary *payload =
|
|
[NSJSONSerialization JSONObjectWithData:payloadData1
|
|
options:NSJSONReadingMutableContainers
|
|
error:&dataError];
|
|
[payload setValue:@[ @"test_key_1", @"test_key_2" ] forKey:@"affectedParameterKeys"];
|
|
NSError *jsonError;
|
|
NSData *payloadData2 = [NSJSONSerialization dataWithJSONObject:payload
|
|
options:kNilOptions
|
|
error:&jsonError];
|
|
NSMutableArray *experimentPayloads = [@[ payloadData1, payloadData2 ] mutableCopy];
|
|
|
|
RCNConfigContent *configContent = [[RCNConfigContent alloc] initWithDBManager:nil];
|
|
NSMutableSet<NSString *> *changedKeys =
|
|
[configContent getKeysAffectedByChangedExperiments:activeExperimentPayloads
|
|
fetchedExperimentPayloads:experimentPayloads];
|
|
XCTAssertTrue([changedKeys containsObject:@"test_key_2"]);
|
|
}
|
|
|
|
- (void)testExperimentDiff_deletedExperiment {
|
|
NSData *payloadData1 = [[self class] payloadDataFromTestFile];
|
|
NSMutableArray *activeExperimentPayloads = [@[ payloadData1 ] mutableCopy];
|
|
NSMutableArray *experimentPayloads = [@[] mutableCopy];
|
|
|
|
RCNConfigContent *configContent = [[RCNConfigContent alloc] initWithDBManager:nil];
|
|
NSMutableSet<NSString *> *changedKeys =
|
|
[configContent getKeysAffectedByChangedExperiments:activeExperimentPayloads
|
|
fetchedExperimentPayloads:experimentPayloads];
|
|
XCTAssertTrue([changedKeys containsObject:@"test_key_1"]);
|
|
}
|
|
|
|
- (void)testExperimentDiff_noChange {
|
|
NSData *payloadData1 = [[self class] payloadDataFromTestFile];
|
|
NSMutableArray *activeExperimentPayloads = [@[ payloadData1 ] mutableCopy];
|
|
NSMutableArray *experimentPayloads = [@[ payloadData1 ] mutableCopy];
|
|
|
|
RCNConfigContent *configContent = [[RCNConfigContent alloc] initWithDBManager:nil];
|
|
NSMutableSet<NSString *> *changedKeys =
|
|
[configContent getKeysAffectedByChangedExperiments:activeExperimentPayloads
|
|
fetchedExperimentPayloads:experimentPayloads];
|
|
XCTAssertTrue([changedKeys count] == 0);
|
|
}
|
|
|
|
- (void)testConfigUpdate_paramAdded_returnsNewKey {
|
|
NSString *namespace = @"test_namespace";
|
|
NSString *newParam = @"key2";
|
|
|
|
// populate active config
|
|
FIRRemoteConfigValue *value =
|
|
[[FIRRemoteConfigValue alloc] initWithData:[@"value1" dataUsingEncoding:NSUTF8StringEncoding]
|
|
source:FIRRemoteConfigSourceRemote];
|
|
NSDictionary *namespaceToConfig = @{namespace : @{@"key1" : value}};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceActive
|
|
forNamespace:namespace];
|
|
|
|
// fetch response has new param
|
|
NSMutableDictionary *fetchResponse =
|
|
[self createFetchResponseWithConfigEntries:@{@"key1" : @"value1", newParam : @"value2"}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:nil];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertTrue([update updatedKeys].count == 1);
|
|
XCTAssertTrue([[update updatedKeys] containsObject:newParam]);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testConfigUpdate_paramValueChanged_returnsUpdatedKey {
|
|
NSString *namespace = @"test_namespace";
|
|
NSString *existingParam = @"key1";
|
|
NSString *oldValue = @"value1";
|
|
NSString *updatedValue = @"value2";
|
|
|
|
// active config contains old value
|
|
FIRRemoteConfigValue *value =
|
|
[[FIRRemoteConfigValue alloc] initWithData:[oldValue dataUsingEncoding:NSUTF8StringEncoding]
|
|
source:FIRRemoteConfigSourceRemote];
|
|
NSDictionary *namespaceToConfig = @{namespace : @{existingParam : value}};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceActive
|
|
forNamespace:namespace];
|
|
|
|
// fetch response contains updated value
|
|
NSMutableDictionary *fetchResponse =
|
|
[self createFetchResponseWithConfigEntries:@{existingParam : updatedValue}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:nil];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertTrue([update updatedKeys].count == 1);
|
|
XCTAssertTrue([[update updatedKeys] containsObject:existingParam]);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testConfigUpdate_paramDeleted_returnsDeletedKey {
|
|
NSString *namespace = @"test_namespace";
|
|
NSString *existingParam = @"key1";
|
|
NSString *newParam = @"key2";
|
|
NSString *value1 = @"value1";
|
|
|
|
// populate active config
|
|
FIRRemoteConfigValue *value =
|
|
[[FIRRemoteConfigValue alloc] initWithData:[value1 dataUsingEncoding:NSUTF8StringEncoding]
|
|
source:FIRRemoteConfigSourceRemote];
|
|
NSDictionary *namespaceToConfig = @{namespace : @{existingParam : value}};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceActive
|
|
forNamespace:namespace];
|
|
|
|
// fetch response does not contain existing param
|
|
NSMutableDictionary *fetchResponse =
|
|
[self createFetchResponseWithConfigEntries:@{newParam : value1}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:nil];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent
|
|
getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertTrue([update updatedKeys].count == 2);
|
|
XCTAssertTrue([[update updatedKeys] containsObject:existingParam]); // deleted
|
|
XCTAssertTrue([[update updatedKeys] containsObject:newParam]); // added
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testConfigUpdate_p13nMetadataUpdated_returnsKey {
|
|
NSString *namespace = @"test_namespace";
|
|
NSString *existingParam = @"key1";
|
|
NSString *value1 = @"value1";
|
|
NSDictionary *oldMetadata = @{@"arm_index" : @"1"};
|
|
NSDictionary *updatedMetadata = @{@"arm_index" : @"2"};
|
|
|
|
// popuate fetched config
|
|
NSMutableDictionary *fetchResponse =
|
|
[self createFetchResponseWithConfigEntries:@{existingParam : value1}
|
|
p13nMetadata:@{existingParam : oldMetadata}
|
|
rolloutMetadata:nil];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
// populate active config with the same content
|
|
[_configContent activatePersonalization];
|
|
FIRRemoteConfigValue *value =
|
|
[[FIRRemoteConfigValue alloc] initWithData:[value1 dataUsingEncoding:NSUTF8StringEncoding]
|
|
source:FIRRemoteConfigSourceRemote];
|
|
NSDictionary *namespaceToConfig = @{namespace : @{existingParam : value}};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceActive
|
|
forNamespace:namespace];
|
|
|
|
// fetched response has updated p13n metadata
|
|
[fetchResponse setValue:@{existingParam : updatedMetadata}
|
|
forKey:RCNFetchResponseKeyPersonalizationMetadata];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertTrue([update updatedKeys].count == 1);
|
|
XCTAssertTrue([[update updatedKeys] containsObject:existingParam]);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testConfigUpdate_rolloutMetadataUpdated_returnsKey {
|
|
NSString *namespace = @"test_namespace";
|
|
NSString *key1 = @"key1";
|
|
NSString *key2 = @"kety2";
|
|
NSString *value = @"value";
|
|
NSString *rolloutId1 = @"1";
|
|
NSString *rolloutId2 = @"2";
|
|
NSString *variantId1 = @"A";
|
|
NSString *variantId2 = @"B";
|
|
NSArray *rolloutMetadata = @[ @{
|
|
RCNFetchResponseKeyRolloutID : rolloutId1,
|
|
RCNFetchResponseKeyVariantID : variantId1,
|
|
RCNFetchResponseKeyAffectedParameterKeys : @[ key1 ]
|
|
} ];
|
|
// Update rolltou metadata
|
|
NSArray *updatedRolloutMetadata = @[
|
|
@{
|
|
RCNFetchResponseKeyRolloutID : rolloutId1,
|
|
RCNFetchResponseKeyVariantID : variantId2,
|
|
RCNFetchResponseKeyAffectedParameterKeys : @[ key1 ]
|
|
},
|
|
@{
|
|
RCNFetchResponseKeyRolloutID : rolloutId2,
|
|
RCNFetchResponseKeyVariantID : variantId1,
|
|
RCNFetchResponseKeyAffectedParameterKeys : @[ key2 ]
|
|
},
|
|
];
|
|
// Populate fetched config
|
|
NSMutableDictionary *fetchResponse = [self createFetchResponseWithConfigEntries:@{key1 : value}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:rolloutMetadata];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
// populate active config with the same content
|
|
[_configContent activateRolloutMetadata:nil];
|
|
XCTAssertEqualObjects(rolloutMetadata, _configContent.activeRolloutMetadata);
|
|
FIRRemoteConfigValue *rcValue =
|
|
[[FIRRemoteConfigValue alloc] initWithData:[value dataUsingEncoding:NSUTF8StringEncoding]
|
|
source:FIRRemoteConfigSourceRemote];
|
|
|
|
NSDictionary *namespaceToConfig = @{namespace : @{key1 : rcValue}};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceActive
|
|
forNamespace:namespace];
|
|
// New fetch response has updated rollout metadata
|
|
[fetchResponse setValue:updatedRolloutMetadata forKey:RCNFetchResponseKeyRolloutMetadata];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertTrue([update updatedKeys].count == 2);
|
|
XCTAssertTrue([[update updatedKeys] containsObject:key1]);
|
|
XCTAssertTrue([[update updatedKeys] containsObject:key2]);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testConfigUpdate_rolloutMetadataDeleted_returnsKey {
|
|
NSString *namespace = @"test_namespace";
|
|
NSString *key1 = @"key1";
|
|
NSString *key2 = @"key2";
|
|
NSString *value = @"value";
|
|
NSString *rolloutId1 = @"1";
|
|
NSString *variantId1 = @"A";
|
|
NSArray *rolloutMetadata = @[ @{
|
|
RCNFetchResponseKeyRolloutID : rolloutId1,
|
|
RCNFetchResponseKeyVariantID : variantId1,
|
|
RCNFetchResponseKeyAffectedParameterKeys : @[ key1, key2 ]
|
|
} ];
|
|
// Remove key2 from rollout metadata
|
|
NSArray *updatedRolloutMetadata = @[ @{
|
|
RCNFetchResponseKeyRolloutID : rolloutId1,
|
|
RCNFetchResponseKeyVariantID : variantId1,
|
|
RCNFetchResponseKeyAffectedParameterKeys : @[ key1 ]
|
|
} ];
|
|
// Populate fetched config
|
|
NSMutableDictionary *fetchResponse =
|
|
[self createFetchResponseWithConfigEntries:@{key1 : value, key2 : value}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:rolloutMetadata];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
// populate active config with the same content
|
|
[_configContent activateRolloutMetadata:nil];
|
|
XCTAssertEqualObjects(rolloutMetadata, _configContent.activeRolloutMetadata);
|
|
FIRRemoteConfigValue *rcValue =
|
|
[[FIRRemoteConfigValue alloc] initWithData:[value dataUsingEncoding:NSUTF8StringEncoding]
|
|
source:FIRRemoteConfigSourceRemote];
|
|
|
|
NSDictionary *namespaceToConfig = @{namespace : @{key1 : rcValue, key2 : rcValue}};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceActive
|
|
forNamespace:namespace];
|
|
// New fetch response has updated rollout metadata
|
|
[fetchResponse setValue:updatedRolloutMetadata forKey:RCNFetchResponseKeyRolloutMetadata];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertTrue([update updatedKeys].count == 1);
|
|
XCTAssertTrue([[update updatedKeys] containsObject:key2]);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testConfigUpdate_rolloutMetadataDeletedAll_returnsKey {
|
|
NSString *namespace = @"test_namespace";
|
|
NSString *key = @"key";
|
|
NSString *value = @"value";
|
|
NSString *rolloutId1 = @"1";
|
|
NSString *variantId1 = @"A";
|
|
NSArray *rolloutMetadata = @[ @{
|
|
RCNFetchResponseKeyRolloutID : rolloutId1,
|
|
RCNFetchResponseKeyVariantID : variantId1,
|
|
RCNFetchResponseKeyAffectedParameterKeys : @[ key ]
|
|
} ];
|
|
// Populate fetched config
|
|
NSMutableDictionary *fetchResponse = [self createFetchResponseWithConfigEntries:@{key : value}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:rolloutMetadata];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
// populate active config with the same content
|
|
[_configContent activateRolloutMetadata:nil];
|
|
XCTAssertEqualObjects(rolloutMetadata, _configContent.activeRolloutMetadata);
|
|
FIRRemoteConfigValue *rcValue =
|
|
[[FIRRemoteConfigValue alloc] initWithData:[value dataUsingEncoding:NSUTF8StringEncoding]
|
|
source:FIRRemoteConfigSourceRemote];
|
|
|
|
NSDictionary *namespaceToConfig = @{namespace : @{key : rcValue}};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceActive
|
|
forNamespace:namespace];
|
|
|
|
// New fetch response has updated rollout metadata
|
|
NSMutableDictionary *updateFetchResponse =
|
|
[self createFetchResponseWithConfigEntries:@{key : value}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:nil];
|
|
[_configContent updateConfigContentWithResponse:updateFetchResponse forNamespace:namespace];
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
[self->_configContent activateRolloutMetadata:nil];
|
|
|
|
XCTAssertTrue([update updatedKeys].count == 1);
|
|
XCTAssertTrue([[update updatedKeys] containsObject:key]);
|
|
XCTAssertTrue(self->_configContent.activeRolloutMetadata.count == 0);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testConfigUpdate_valueSourceChanged_returnsKey {
|
|
NSString *namespace = @"test_namespace";
|
|
NSString *existingParam = @"key1";
|
|
NSString *value1 = @"value1";
|
|
|
|
// set default config
|
|
FIRRemoteConfigValue *value =
|
|
[[FIRRemoteConfigValue alloc] initWithData:[value1 dataUsingEncoding:NSUTF8StringEncoding]
|
|
source:FIRRemoteConfigSourceDefault];
|
|
NSDictionary *namespaceToConfig = @{namespace : @{existingParam : value}};
|
|
[_configContent copyFromDictionary:namespaceToConfig
|
|
toSource:RCNDBSourceDefault
|
|
forNamespace:namespace];
|
|
|
|
// fetch response contains same key->value
|
|
NSMutableDictionary *fetchResponse =
|
|
[self createFetchResponseWithConfigEntries:@{existingParam : value1}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:nil];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertTrue([update updatedKeys].count == 1);
|
|
XCTAssertTrue([[update updatedKeys] containsObject:existingParam]);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
#pragma mark - Malformed server responses
|
|
|
|
- (void)testUpdateConfigContentWithMalformedStateIsIgnored {
|
|
NSString *namespace = @"test_namespace";
|
|
NSArray *malformedStates = @[ @1, [NSNull null], @[ @"UPDATE" ], @{@"state" : @"UPDATE"} ];
|
|
for (id state in malformedStates) {
|
|
NSDictionary *response = @{RCNFetchResponseKeyState : state, @"entries" : @{@"key" : @"value"}};
|
|
XCTAssertNoThrow([_configContent updateConfigContentWithResponse:response
|
|
forNamespace:namespace]);
|
|
}
|
|
XCTAssertNil(_configContent.fetchedConfig[namespace]);
|
|
}
|
|
|
|
- (void)testUpdateConfigContentWithMalformedEntriesKeepsValidValues {
|
|
NSString *namespace = @"test_namespace";
|
|
|
|
// Seed a valid value so the retention checks below are meaningful.
|
|
NSDictionary *seedResponse = [self createFetchResponseWithConfigEntries:@{@"valid" : @"value"}
|
|
p13nMetadata:nil
|
|
rolloutMetadata:nil];
|
|
[_configContent updateConfigContentWithResponse:seedResponse forNamespace:namespace];
|
|
XCTAssertEqual([_configContent.fetchedConfig[namespace] count], 1);
|
|
|
|
// A non-dictionary `entries` drops the whole update and leaves the stored values untouched.
|
|
NSArray *malformedEntries = @[ @"entries", @[ @"key", @"value" ], [NSNull null], @1 ];
|
|
for (id entries in malformedEntries) {
|
|
NSDictionary *response = @{
|
|
RCNFetchResponseKeyState : RCNFetchResponseKeyStateUpdate,
|
|
RCNFetchResponseKeyEntries : entries
|
|
};
|
|
XCTAssertNoThrow([_configContent updateConfigContentWithResponse:response
|
|
forNamespace:namespace]);
|
|
NSDictionary *fetchedConfig = _configContent.fetchedConfig[namespace];
|
|
XCTAssertEqual(fetchedConfig.count, 1);
|
|
XCTAssertEqualObjects([fetchedConfig[@"valid"] stringValue], @"value");
|
|
}
|
|
|
|
// A dictionary `entries` with some non-string values applies the update and skips only the
|
|
// invalid values.
|
|
NSDictionary *entries = @{
|
|
@"valid" : @"value2",
|
|
@"number" : @1,
|
|
@"null" : [NSNull null],
|
|
@"array" : @[ @"value" ],
|
|
@"dictionary" : @{@"key" : @"value"}
|
|
};
|
|
NSDictionary *response = [self createFetchResponseWithConfigEntries:entries
|
|
p13nMetadata:nil
|
|
rolloutMetadata:nil];
|
|
XCTAssertNoThrow([_configContent updateConfigContentWithResponse:response
|
|
forNamespace:namespace]);
|
|
NSDictionary *fetchedConfig = _configContent.fetchedConfig[namespace];
|
|
XCTAssertEqual(fetchedConfig.count, 1);
|
|
XCTAssertEqualObjects([fetchedConfig[@"valid"] stringValue], @"value2");
|
|
}
|
|
|
|
- (void)testUpdateConfigContentWithMalformedMetadataDoesNotCrash {
|
|
NSString *namespace = @"test_namespace";
|
|
NSArray *malformedValues = @[ @"metadata", @1, [NSNull null] ];
|
|
for (id value in malformedValues) {
|
|
NSDictionary *response = @{
|
|
RCNFetchResponseKeyState : RCNFetchResponseKeyStateUpdate,
|
|
RCNFetchResponseKeyEntries : @{@"key" : @"value"},
|
|
RCNFetchResponseKeyPersonalizationMetadata : value,
|
|
RCNFetchResponseKeyRolloutMetadata : value
|
|
};
|
|
XCTAssertNoThrow([_configContent updateConfigContentWithResponse:response
|
|
forNamespace:namespace]);
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent
|
|
getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertEqualObjects([update updatedKeys], [NSSet setWithObject:@"key"]);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
}
|
|
|
|
- (void)testConfigUpdate_malformedP13nMetadataValue_returnsKey {
|
|
NSString *namespace = @"test_namespace";
|
|
NSString *key = @"key";
|
|
// Activate personalization metadata whose per-parameter value is not a dictionary.
|
|
NSMutableDictionary *fetchResponse =
|
|
[self createFetchResponseWithConfigEntries:nil
|
|
p13nMetadata:@{key : @"not a dictionary"}
|
|
rolloutMetadata:nil];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
[_configContent activatePersonalization];
|
|
|
|
fetchResponse = [self createFetchResponseWithConfigEntries:nil
|
|
p13nMetadata:@{key : @{@"choiceId" : @"id1"}}
|
|
rolloutMetadata:nil];
|
|
[_configContent updateConfigContentWithResponse:fetchResponse forNamespace:namespace];
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent
|
|
getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertEqualObjects([update updatedKeys], [NSSet setWithObject:key]);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testConfigUpdate_malformedRolloutMetadataEntriesAreSkipped {
|
|
NSString *namespace = @"test_namespace";
|
|
NSArray *rolloutMetadata = @[
|
|
@"not a dictionary", [NSNull null], @{
|
|
RCNFetchResponseKeyRolloutID : @1,
|
|
RCNFetchResponseKeyVariantID : @"A",
|
|
RCNFetchResponseKeyAffectedParameterKeys : @[ @"numberRolloutId" ]
|
|
},
|
|
@{
|
|
RCNFetchResponseKeyRolloutID : @"rollout_1",
|
|
RCNFetchResponseKeyVariantID : [NSNull null],
|
|
RCNFetchResponseKeyAffectedParameterKeys : @[ @"nullVariantId" ]
|
|
},
|
|
@{
|
|
RCNFetchResponseKeyRolloutID : @"rollout_1",
|
|
RCNFetchResponseKeyVariantID : @"A",
|
|
RCNFetchResponseKeyAffectedParameterKeys : @"stringKeys"
|
|
},
|
|
@{
|
|
RCNFetchResponseKeyRolloutID : @"rollout_2",
|
|
RCNFetchResponseKeyVariantID : @"B",
|
|
RCNFetchResponseKeyAffectedParameterKeys : @[ @"validKey", @2, [NSNull null] ]
|
|
}
|
|
];
|
|
NSMutableDictionary *fetchResponse = [self createFetchResponseWithConfigEntries:nil
|
|
p13nMetadata:nil
|
|
rolloutMetadata:rolloutMetadata];
|
|
XCTAssertNoThrow([_configContent updateConfigContentWithResponse:fetchResponse
|
|
forNamespace:namespace]);
|
|
|
|
XCTestExpectation *expectation = [self expectationWithDescription:NSStringFromSelector(_cmd)];
|
|
[_configContent
|
|
getConfigUpdateForNamespace:namespace
|
|
completionHandler:^(FIRRemoteConfigUpdate *update) {
|
|
XCTAssertEqualObjects([update updatedKeys], [NSSet setWithObject:@"validKey"]);
|
|
[expectation fulfill];
|
|
}];
|
|
[self waitForExpectationsWithTimeout:5.0 handler:nil];
|
|
}
|
|
|
|
- (void)testExperimentsWithNonStringAffectedKeysOnlyReturnStringKeys {
|
|
NSDictionary *experiment = @{
|
|
@"experimentId" : @"exp_1",
|
|
@"variantId" : @"1",
|
|
@"affectedParameterKeys" : @[ @"validKey", @1, [NSNull null], @{} ]
|
|
};
|
|
NSData *payload = [NSJSONSerialization dataWithJSONObject:experiment options:0 error:nil];
|
|
NSMutableSet<NSString *> *changedKeys =
|
|
[_configContent getKeysAffectedByChangedExperiments:[NSMutableArray array]
|
|
fetchedExperimentPayloads:[@[ payload ] mutableCopy]];
|
|
XCTAssertEqualObjects(changedKeys, [NSSet setWithObject:@"validKey"]);
|
|
}
|
|
|
|
#pragma mark - Test Helpers
|
|
|
|
- (NSMutableDictionary *)createFetchResponseWithConfigEntries:(NSDictionary *)config
|
|
p13nMetadata:(NSDictionary *)p13nMetadata
|
|
rolloutMetadata:(NSArray *)rolloutMetadata {
|
|
NSMutableDictionary *fetchResponse = [[NSMutableDictionary alloc]
|
|
initWithObjectsAndKeys:RCNFetchResponseKeyStateUpdate, RCNFetchResponseKeyState, nil];
|
|
if (config) {
|
|
[fetchResponse setValue:config forKey:RCNFetchResponseKeyEntries];
|
|
}
|
|
if (p13nMetadata) {
|
|
[fetchResponse setValue:p13nMetadata forKey:RCNFetchResponseKeyPersonalizationMetadata];
|
|
}
|
|
if (rolloutMetadata) {
|
|
[fetchResponse setValue:rolloutMetadata forKey:RCNFetchResponseKeyRolloutMetadata];
|
|
}
|
|
return fetchResponse;
|
|
}
|
|
|
|
+ (NSData *)payloadDataFromTestFile {
|
|
#if SWIFT_PACKAGE
|
|
NSBundle *bundle = SWIFTPM_MODULE_BUNDLE;
|
|
#else
|
|
NSBundle *bundle = [NSBundle bundleForClass:[self class]];
|
|
#endif
|
|
NSString *testJsonDataFilePath = [bundle pathForResource:@"TestABTPayload" ofType:@"txt"];
|
|
NSError *readTextError = nil;
|
|
NSString *fileText = [[NSString alloc] initWithContentsOfFile:testJsonDataFilePath
|
|
encoding:NSUTF8StringEncoding
|
|
error:&readTextError];
|
|
|
|
NSData *fileData = [fileText dataUsingEncoding:NSUTF8StringEncoding];
|
|
|
|
NSError *jsonDictionaryError = nil;
|
|
NSMutableDictionary *jsonDictionary =
|
|
[[NSJSONSerialization JSONObjectWithData:fileData
|
|
options:kNilOptions
|
|
error:&jsonDictionaryError] mutableCopy];
|
|
NSError *jsonDataError = nil;
|
|
return [NSJSONSerialization dataWithJSONObject:jsonDictionary
|
|
options:kNilOptions
|
|
error:&jsonDataError];
|
|
}
|
|
|
|
@end
|