updated tests, variable names, and method info for permission manager, filter, and status objects

8 files changed, 209 insertions, 96 deletions

diff --git a/SmartDeviceLink/SDLPermissionFilter.h b/SmartDeviceLink/SDLPermissionFilter.h
index 0dd19452b..d2ba93956 100644
--- a/SmartDeviceLink/SDLPermissionFilter.h
+++ b/SmartDeviceLink/SDLPermissionFilter.h
@@ -50,7 +50,7 @@ NS_ASSUME_NONNULL_BEGIN
  *
  *  @return An instance of `SDLPermissionFilter`.
  */
-- (instancetype)initWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType observer:(nullable SDLPermissionsChangedHandler)handler rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler NS_DESIGNATED_INITIALIZER;
+- (instancetype)initWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)handler rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler NS_DESIGNATED_INITIALIZER;
 
 /**
  *  Create a new permission filter group.
@@ -61,7 +61,7 @@ NS_ASSUME_NONNULL_BEGIN
  *
  *  @return An instance of `SDLPermissionFilter`.
  */
-+ (instancetype)filterWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType observer:(nullable SDLPermissionsChangedHandler)handler rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler NS_SWIFT_UNAVAILABLE("Use the initializer");
++ (instancetype)filterWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)handler rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler NS_SWIFT_UNAVAILABLE("Use the initializer");
 
 /**
  *  Whether the current filter is equivalent with another filter or not.
@@ -72,7 +72,13 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (BOOL)isEqualToFilter:(SDLPermissionFilter *)otherFilter;
 
-// to do update
+/**
+ *  Converts an array of SDLPermissionElement objects to and array of SDLPermissionRPCName objects
+ *
+ *  @param permissionElements The permission elements to convert.
+ *
+ *  @return An array of SDLPermissionRPCName objects
+ */
 - (NSArray<SDLPermissionRPCName> *)getRPCNamesFromPermissionElements:(NSArray<SDLPermissionElement *> *)permissionElements;
 
 @end
diff --git a/SmartDeviceLink/SDLPermissionFilter.m b/SmartDeviceLink/SDLPermissionFilter.m
index 9507faf95..bfa3f8540 100644
--- a/SmartDeviceLink/SDLPermissionFilter.m
+++ b/SmartDeviceLink/SDLPermissionFilter.m
@@ -19,10 +19,10 @@ NS_ASSUME_NONNULL_BEGIN
 - (instancetype)init {
     return [self initWithRPCNames:@[]
                         groupType:SDLPermissionGroupTypeAny
-                         observer:^(NSDictionary<SDLPermissionElement *, NSNumber<SDLBool> *> *_Nonnull change, SDLPermissionGroupStatus status){ } rpcPermissionStatusHandler:^(NSDictionary<SDLPermissionRPCName,SDLRPCPermissionStatus *> * _Nonnull change, SDLPermissionGroupStatus status) { }];
+                         permissionsHandler:^(NSDictionary<SDLPermissionElement *, NSNumber<SDLBool> *> *_Nonnull change, SDLPermissionGroupStatus status){ } rpcPermissionStatusHandler:^(NSDictionary<SDLPermissionRPCName,SDLRPCPermissionStatus *> * _Nonnull change, SDLPermissionGroupStatus status) { }];
 }
 
-- (instancetype)initWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType observer:(nullable SDLPermissionsChangedHandler)observer rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler {
+- (instancetype)initWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)observer rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler {
     self = [super init];
     if (!self) {
         return nil;
@@ -37,15 +37,15 @@ NS_ASSUME_NONNULL_BEGIN
     return self;
 }
 
-+ (instancetype)filterWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType observer:(nullable SDLPermissionsChangedHandler)observer rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler {
-    return [[self alloc] initWithRPCNames:rpcNames groupType:groupType observer:observer rpcPermissionStatusHandler:permissionStatusHandler];
++ (instancetype)filterWithRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType permissionsHandler:(nullable SDLPermissionsChangedHandler)observer rpcPermissionStatusHandler:(nullable SDLRPCPermissionStatusChangedHandler)permissionStatusHandler {
+    return [[self alloc] initWithRPCNames:rpcNames groupType:groupType permissionsHandler:observer rpcPermissionStatusHandler:permissionStatusHandler];
 }
 
 
 #pragma mark - NSCopying
 
 - (id)copyWithZone:(nullable NSZone *)zone {
-    SDLPermissionFilter *newFilter = [[self.class allocWithZone:zone] initWithRPCNames:[_permissionElements copyWithZone:zone] groupType:_groupType observer:[_handler copyWithZone:zone] rpcPermissionStatusHandler:[_rpcPermissionStatusHandler copyWithZone:zone]];
+    SDLPermissionFilter *newFilter = [[self.class allocWithZone:zone] initWithRPCNames:[_permissionElements copyWithZone:zone] groupType:_groupType permissionsHandler:[_handler copyWithZone:zone] rpcPermissionStatusHandler:[_rpcPermissionStatusHandler copyWithZone:zone]];
     newFilter->_identifier = _identifier;
 
     return newFilter;
diff --git a/SmartDeviceLink/SDLPermissionManager.m b/SmartDeviceLink/SDLPermissionManager.m
index d28302440..4c18c1fe8 100644
--- a/SmartDeviceLink/SDLPermissionManager.m
+++ b/SmartDeviceLink/SDLPermissionManager.m
@@ -134,8 +134,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (NSDictionary<SDLPermissionRPCName, NSNumber *> *)statusOfRPCs:(NSArray<SDLPermissionRPCName> *)rpcNames {
     NSArray *permissionElementsArray = [self sdl_createPermissionElementFromRPCNames:rpcNames];
-    NSDictionary *dict = [self statusesOfRPCNames:permissionElementsArray];
-    return [self sdl_convertPermissionsDictionary:dict];
+    return [self sdl_convertPermissionsDictionary:[self statusesOfRPCNames:permissionElementsArray]];
 }
 
 - (NSDictionary<SDLRPCFunctionName, SDLRPCPermissionStatus *> *)statusesOfRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames {
@@ -154,7 +153,7 @@ NS_ASSUME_NONNULL_BEGIN
             }
         }
 
-        SDLRPCPermissionStatus *permissionStatus = [[SDLRPCPermissionStatus alloc] initWithRPCName:permissionElement.rpcName isRPCAllowed:[self isRPCNameAllowed:permissionElement.rpcName] allowedParameters:allowedParameters];
+        SDLRPCPermissionStatus *permissionStatus = [[SDLRPCPermissionStatus alloc] initWithRPCName:permissionElement.rpcName isRPCAllowed:[self isRPCNameAllowed:permissionElement.rpcName] rpcParameters:allowedParameters];
         [permissionAllowedDict setObject:permissionStatus forKey:permissionElement.rpcName];
     }
 
@@ -167,7 +166,7 @@ NS_ASSUME_NONNULL_BEGIN
 #pragma mark Add Observers
 
 - (SDLPermissionObserverIdentifier)addObserverForRPCs:(NSArray<SDLPermissionRPCName> *)rpcNames groupType:(SDLPermissionGroupType)groupType withHandler:(nonnull SDLPermissionsChangedHandler)handler {
-    SDLPermissionFilter *filter = [SDLPermissionFilter filterWithRPCNames:[self sdl_createPermissionElementFromRPCNames:rpcNames] groupType:groupType observer:handler rpcPermissionStatusHandler:nil];
+    SDLPermissionFilter *filter = [SDLPermissionFilter filterWithRPCNames:[self sdl_createPermissionElementFromRPCNames:rpcNames] groupType:groupType permissionsHandler:handler rpcPermissionStatusHandler:nil];
 
     // Store the filter for later use
     [self.filters addObject:filter];
@@ -179,7 +178,7 @@ NS_ASSUME_NONNULL_BEGIN
 }
 
 - (SDLPermissionObserverIdentifier)subscribeToRPCNames:(NSArray<SDLPermissionElement *> *)rpcNames groupType:(SDLPermissionGroupType)groupType withHandler:(SDLRPCPermissionStatusChangedHandler)handler {
-    SDLPermissionFilter *filter = [SDLPermissionFilter filterWithRPCNames:rpcNames groupType:groupType observer:nil rpcPermissionStatusHandler:handler];
+    SDLPermissionFilter *filter = [SDLPermissionFilter filterWithRPCNames:rpcNames groupType:groupType permissionsHandler:nil rpcPermissionStatusHandler:handler];
 
     // Store the filter for later use
     [self.filters addObject:filter];
@@ -203,7 +202,7 @@ NS_ASSUME_NONNULL_BEGIN
 
     if (filter.handler != nil) {
         SDLPermissionGroupStatus permissionStatus = [self groupStatusOfRPCNames:filter.permissionElements];
-        NSDictionary<SDLRPCFunctionName, NSNumber *> *allowedDict = [self statusOfRPCs:[filter getRPCNamesFromPermissionElements:filter.permissionElements]];
+        NSDictionary<SDLRPCFunctionName, NSNumber *> *allowedDict = [self sdl_convertPermissionsDictionary:[self statusesOfRPCNames:filter.permissionElements]];
         filter.handler(allowedDict, permissionStatus);
     }
 }
@@ -312,15 +311,29 @@ NS_ASSUME_NONNULL_BEGIN
 
 #pragma mark Helper Methods
 
-- (NSDictionary<SDLPermissionRPCName, NSNumber *> *)sdl_convertPermissionsDictionary:(NSDictionary<SDLRPCFunctionName, SDLRPCPermissionStatus*> *)permissionElementsDictionary {
+/**
+ *  HAX: Remove this when statusOfRPCs: is no longer supported. Converts a dictionary from <SDLRPCFunctionName, SDLRPCPermissionStatus*> to <SDLPermissionRPCName, NSNumber *>.
+ *
+ *  @param permissionStatusDictionary The dictionary containing <SDLRPCFunctionName, SDLRPCPermissionStatus*> to convert.
+ *
+ *  @return A  <SDLPermissionRPCName, NSNumber *> dictionary.
+ */
+- (NSDictionary<SDLPermissionRPCName, NSNumber *> *)sdl_convertPermissionsDictionary:(NSDictionary<SDLRPCFunctionName, SDLRPCPermissionStatus*> *)permissionStatusDictionary {
     NSMutableDictionary *rpcNameDictionary = [[NSMutableDictionary alloc] init];
-    [permissionElementsDictionary enumerateKeysAndObjectsUsingBlock:^(SDLRPCFunctionName _Nonnull key, SDLRPCPermissionStatus * _Nonnull obj, BOOL * _Nonnull stop) {
+    [permissionStatusDictionary enumerateKeysAndObjectsUsingBlock:^(SDLRPCFunctionName _Nonnull key, SDLRPCPermissionStatus * _Nonnull obj, BOOL * _Nonnull stop) {
         [rpcNameDictionary setObject:@(obj.rpcAllowed) forKey:key];
     }];
 
     return rpcNameDictionary;
 }
 
+/**
+ *  Converts an array of RPC name strings to permission elements.
+ *
+ *  @param rpcNames The RPC names to convert.
+ *
+ *  @return An array of permission elements.
+ */
 - (NSArray<SDLPermissionElement *> *)sdl_createPermissionElementFromRPCNames:(NSArray<NSString *> *)rpcNames {
     NSMutableArray *permissionElements = [NSMutableArray new];
     for (NSString *rpcName in rpcNames) {
diff --git a/SmartDeviceLink/SDLRPCPermissionStatus.h b/SmartDeviceLink/SDLRPCPermissionStatus.h
index 9229ee74c..037edbcc4 100644
--- a/SmartDeviceLink/SDLRPCPermissionStatus.h
+++ b/SmartDeviceLink/SDLRPCPermissionStatus.h
@@ -29,10 +29,18 @@ NS_ASSUME_NONNULL_BEGIN
 /**
  * Holds a dictionary of RPC parameters and their permission status
  */
-@property (strong, nonatomic, nullable, readonly) NSMutableDictionary<NSString *, NSNumber *> *allowedParameters;
+@property (strong, nonatomic, nullable, readonly) NSMutableDictionary<NSString *, NSNumber *> *rpcParameters;
 
-// to do add description
-- (instancetype)initWithRPCName:(SDLRPCFunctionName)rpcName isRPCAllowed:(BOOL)isRPCAllowed allowedParameters:(nullable NSDictionary<NSString *, NSNumber *> *)allowedParameters;
+/**
+ *  Initializes a SDLRPCPermissionStatus object.
+ *
+ *  @param rpcName The name of the RPC.
+ *  @param isRPCAllowed The permission status for the RPC.
+ *  @param rpcParameters A dictionary that containers parameter permission status information.
+ *
+ *  @return An instance of the SDLRPCPermissionStatus class.
+ */
+- (instancetype)initWithRPCName:(SDLRPCFunctionName)rpcName isRPCAllowed:(BOOL)isRPCAllowed rpcParameters:(nullable NSDictionary<NSString *, NSNumber *> *)rpcParameters;
 
 @end
 
diff --git a/SmartDeviceLink/SDLRPCPermissionStatus.m b/SmartDeviceLink/SDLRPCPermissionStatus.m
index f868ab267..edc64dc89 100644
--- a/SmartDeviceLink/SDLRPCPermissionStatus.m
+++ b/SmartDeviceLink/SDLRPCPermissionStatus.m
@@ -10,10 +10,10 @@
 
 @implementation SDLRPCPermissionStatus
 
-- (instancetype)initWithRPCName:(SDLRPCFunctionName)rpcName isRPCAllowed:(BOOL)isRPCAllowed allowedParameters:(nullable NSMutableDictionary<NSString *,NSNumber *> *)allowedParameters {
+- (instancetype)initWithRPCName:(SDLRPCFunctionName)rpcName isRPCAllowed:(BOOL)isRPCAllowed rpcParameters:(nullable NSMutableDictionary<NSString *,NSNumber *> *)rpcParameters {
     _rpcName = rpcName;
     _rpcAllowed = isRPCAllowed;
-    _allowedParameters = allowedParameters;
+    _rpcParameters = rpcParameters;
 
     return self;
 }
diff --git a/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionFilterSpec.m b/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionFilterSpec.m
index c3e482f18..524fdf923 100644
--- a/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionFilterSpec.m
+++ b/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionFilterSpec.m
@@ -26,83 +26,157 @@ describe(@"A filter", ^{
         __block SDLPermissionFilter *testFilter = nil;
 
         __block NSDictionary<SDLPermissionRPCName, NSNumber<SDLBool> *> *testObserverReturnChangedDict = nil;
+        __block NSDictionary<SDLPermissionRPCName, SDLRPCPermissionStatus *> *testRPCPermissionStatusReturnChangedDict = nil;
 
         beforeEach(^{
             testPermissionElements = @[testPermissionElement1, testPermissionElement2];
             testGroupType = SDLPermissionGroupTypeAny;
         });
 
-        context(@"using initWithRPCNames:changeType:observer:", ^{
-            beforeEach(^{
-//                testFilter = [[SDLPermissionFilter alloc] initWithRPCNames:testPermissionElements groupType:testGroupType observer:^(NSDictionary<SDLPermissionRPCName,NSNumber *> * _Nonnull change, SDLPermissionGroupStatus status) {
-//
-//                } rpcPermissionStatusHandler:^(NSDictionary<SDLPermissionRPCName,SDLRPCPermissionStatus *> * _Nonnull change, SDLPermissionGroupStatus status) {
-//
-//                }];
-                testFilter = [[SDLPermissionFilter alloc] initWithRPCNames:testPermissionElements groupType:testGroupType observer:^(NSDictionary<SDLPermissionRPCName,NSNumber *> * _Nonnull change, SDLPermissionGroupStatus status) { testObserverReturnChangedDict = change; } rpcPermissionStatusHandler:nil];
-            });
+        context(@"using initWithRPCNames:changeType:permissionsHandler:rpcPermissionStatusHandler", ^{
+            context(@"and the rpcPermissionStatusHandler is nil", ^{
+                beforeEach(^{
+                    testFilter = [[SDLPermissionFilter alloc] initWithRPCNames:testPermissionElements groupType:testGroupType permissionsHandler:^(NSDictionary<SDLPermissionRPCName,NSNumber *> * _Nonnull change, SDLPermissionGroupStatus status) { testObserverReturnChangedDict = change; } rpcPermissionStatusHandler:nil];
+                });
 
-            it(@"should set the rpcNames array correctly", ^{
-                expect(testFilter.permissionElements).to(equal(testPermissionElements));
-            });
+                it(@"should set the rpcNames array correctly", ^{
+                    expect(testFilter.permissionElements).to(equal(testPermissionElements));
+                });
 
-            describe(@"it should set up the observer correctly", ^{
-                __block NSDictionary<SDLPermissionRPCName,NSNumber<SDLBool> *> *testObserverChangedDict = nil;
-                __block NSNumber<SDLBool> *testRPCName1Bool = nil;
-                __block NSNumber<SDLBool> *testRPCName2Bool = nil;
-                __block SDLPermissionGroupStatus testObserverGroupStatus = SDLPermissionGroupStatusUnknown;
+                describe(@"it should set up the observer correctly", ^{
+                    __block NSDictionary<SDLPermissionRPCName,NSNumber<SDLBool> *> *testObserverChangedDict = nil;
+                    __block NSNumber<SDLBool> *testRPCName1Bool = nil;
+                    __block NSNumber<SDLBool> *testRPCName2Bool = nil;
+                    __block SDLPermissionGroupStatus testObserverGroupStatus = SDLPermissionGroupStatusUnknown;
+
+                    beforeEach(^{
+                        testRPCName1Bool = @YES;
+                        testRPCName2Bool = @NO;
+                        testObserverChangedDict = @{testRPCName1: testRPCName1Bool,
+                                                    testRPCName2: testRPCName2Bool};
+                        testObserverGroupStatus = SDLPermissionGroupStatusMixed;
+
+                        testFilter.handler(testObserverChangedDict, testObserverGroupStatus);
+                    });
+
+                    it(@"should call the changedDict correctly", ^{
+                        expect(testObserverReturnChangedDict).to(equal(testObserverChangedDict));
+                    });
+
+                    it(@"should call the status correctly", ^{
+                        expect(@(testObserverGroupStatus)).to(equal(@(testObserverGroupStatus)));
+                    });
+                });
+            });
 
+            context(@"and the permissionsHandler is nil", ^{
                 beforeEach(^{
-                    testRPCName1Bool = @YES;
-                    testRPCName2Bool = @NO;
-                    testObserverChangedDict = @{testRPCName1: testRPCName1Bool,
-                                                testRPCName2: testRPCName2Bool};
-                    testObserverGroupStatus = SDLPermissionGroupStatusMixed;
-
-                    testFilter.handler(testObserverChangedDict, testObserverGroupStatus);
+                    testFilter = [[SDLPermissionFilter alloc] initWithRPCNames:testPermissionElements groupType:testGroupType permissionsHandler:nil rpcPermissionStatusHandler:^(NSDictionary<SDLPermissionRPCName,SDLRPCPermissionStatus *> * _Nonnull change, SDLPermissionGroupStatus status) {
+                        testRPCPermissionStatusReturnChangedDict = change;
+                    }];
                 });
 
-                it(@"should call the changedDict correctly", ^{
-                    expect(testObserverReturnChangedDict).to(equal(testObserverChangedDict));
+                it(@"should set the rpcNames array correctly", ^{
+                    expect(testFilter.permissionElements).to(equal(testPermissionElements));
                 });
 
-                it(@"should call the status correctly", ^{
-                    expect(@(testObserverGroupStatus)).to(equal(@(testObserverGroupStatus)));
+                describe(@"it should set up the observer correctly", ^{
+                    __block NSDictionary<SDLPermissionRPCName, SDLRPCPermissionStatus *> *testObserverChangedDict = nil;
+                    __block SDLRPCPermissionStatus *rpcPermissionStatus1 = nil;
+                    __block SDLRPCPermissionStatus *rpcPermissionStatus2 = nil;
+                    __block SDLPermissionGroupStatus testObserverGroupStatus = SDLPermissionGroupStatusUnknown;
+
+                    beforeEach(^{
+                        rpcPermissionStatus1 = [[SDLRPCPermissionStatus alloc] initWithRPCName:testRPCName1 isRPCAllowed:YES rpcParameters:nil];
+                        rpcPermissionStatus2 = [[SDLRPCPermissionStatus alloc] initWithRPCName:testRPCName2 isRPCAllowed:NO rpcParameters:nil];
+                        testObserverChangedDict = @{testRPCName1: rpcPermissionStatus1,
+                                                    testRPCName2: rpcPermissionStatus2};
+                        testObserverGroupStatus = SDLPermissionGroupStatusMixed;
+
+                        testFilter.rpcPermissionStatusHandler(testObserverChangedDict, testObserverGroupStatus);
+                    });
+
+                    it(@"should call the changedDict correctly", ^{
+                        expect(testRPCPermissionStatusReturnChangedDict).to(equal(testObserverChangedDict));
+                    });
+
+                    it(@"should call the status correctly", ^{
+                        expect(@(testObserverGroupStatus)).to(equal(@(testObserverGroupStatus)));
+                    });
                 });
             });
         });
 
         context(@"using filterWithRPCNames:changeType:observer:", ^{
-            beforeEach(^{
-                testFilter = [SDLPermissionFilter filterWithRPCNames:testPermissionElements groupType:testGroupType observer:^(NSDictionary<SDLPermissionRPCName, NSNumber<SDLBool> *> * _Nonnull change, SDLPermissionGroupStatus status) { testObserverReturnChangedDict = change; } rpcPermissionStatusHandler:nil];
-            });
+            context(@"and the rpcPermissionStatusHandler is nil", ^{
+                beforeEach(^{
+                    testFilter = [SDLPermissionFilter filterWithRPCNames:testPermissionElements groupType:testGroupType permissionsHandler:^(NSDictionary<SDLPermissionRPCName, NSNumber<SDLBool> *> * _Nonnull change, SDLPermissionGroupStatus status) { testObserverReturnChangedDict = change; } rpcPermissionStatusHandler:nil];
+                });
 
-            it(@"should set the rpcNames array correctly", ^{
-                expect(testFilter.permissionElements).to(equal(testPermissionElements));
-            });
+                it(@"should set the rpcNames array correctly", ^{
+                    expect(testFilter.permissionElements).to(equal(testPermissionElements));
+                });
 
-            describe(@"it should set up the observer correctly", ^{
-                __block NSDictionary<SDLPermissionRPCName, NSNumber<SDLBool> *> *testObserverChangedDict = nil;
-                __block NSNumber<SDLBool> *testRPCName1Bool = nil;
-                __block NSNumber<SDLBool> *testRPCName2Bool = nil;
-                __block SDLPermissionGroupStatus testObserverGroupStatus = SDLPermissionGroupStatusUnknown;
+                describe(@"it should set up the observer correctly", ^{
+                    __block NSDictionary<SDLPermissionRPCName, NSNumber<SDLBool> *> *testObserverChangedDict = nil;
+                    __block NSNumber<SDLBool> *testRPCName1Bool = nil;
+                    __block NSNumber<SDLBool> *testRPCName2Bool = nil;
+                    __block SDLPermissionGroupStatus testObserverGroupStatus = SDLPermissionGroupStatusUnknown;
+
+                    beforeEach(^{
+                        testRPCName1Bool = @YES;
+                        testRPCName2Bool = @NO;
+                        testObserverChangedDict = @{testRPCName1: testRPCName1Bool,
+                                                    testRPCName2: testRPCName2Bool};
+                        testObserverGroupStatus = SDLPermissionGroupStatusMixed;
+
+                        testFilter.handler(testObserverChangedDict, testObserverGroupStatus);
+                    });
+
+                    it(@"should call the changedDict correctly", ^{
+                        expect(testObserverReturnChangedDict).to(equal(testObserverChangedDict));
+                    });
+
+                    it(@"should call the status correctly", ^{
+                        expect(@(testObserverGroupStatus)).to(equal(@(testObserverGroupStatus)));
+                    });
+                });
+            });
 
+            context(@"and the permissionsHandler is nil", ^{
                 beforeEach(^{
-                    testRPCName1Bool = @YES;
-                    testRPCName2Bool = @NO;
-                    testObserverChangedDict = @{testRPCName1: testRPCName1Bool,
-                                                testRPCName2: testRPCName2Bool};
-                    testObserverGroupStatus = SDLPermissionGroupStatusMixed;
-
-                    testFilter.handler(testObserverChangedDict, testObserverGroupStatus);
+                    testFilter = [SDLPermissionFilter filterWithRPCNames:testPermissionElements groupType:testGroupType permissionsHandler:nil rpcPermissionStatusHandler:^(NSDictionary<SDLPermissionRPCName,SDLRPCPermissionStatus *> * _Nonnull change, SDLPermissionGroupStatus status) {
+                        testRPCPermissionStatusReturnChangedDict = change;
+                    }];
                 });
 
-                it(@"should call the changedDict correctly", ^{
-                    expect(testObserverReturnChangedDict).to(equal(testObserverChangedDict));
+                it(@"should set the rpcNames array correctly", ^{
+                    expect(testFilter.permissionElements).to(equal(testPermissionElements));
                 });
 
-                it(@"should call the status correctly", ^{
-                    expect(@(testObserverGroupStatus)).to(equal(@(testObserverGroupStatus)));
+                describe(@"it should set up the observer correctly", ^{
+                    __block NSDictionary<SDLPermissionRPCName, SDLRPCPermissionStatus *> *testObserverChangedDict = nil;
+                    __block SDLRPCPermissionStatus *rpcPermissionStatus1 = nil;
+                    __block SDLRPCPermissionStatus *rpcPermissionStatus2 = nil;
+                    __block SDLPermissionGroupStatus testObserverGroupStatus = SDLPermissionGroupStatusUnknown;
+
+                    beforeEach(^{
+                        rpcPermissionStatus1 = [[SDLRPCPermissionStatus alloc] initWithRPCName:testRPCName1 isRPCAllowed:YES rpcParameters:nil];
+                        rpcPermissionStatus2 = [[SDLRPCPermissionStatus alloc] initWithRPCName:testRPCName2 isRPCAllowed:NO rpcParameters:nil];
+                        testObserverChangedDict = @{testRPCName1: rpcPermissionStatus1,
+                                                    testRPCName2: rpcPermissionStatus2};
+                        testObserverGroupStatus = SDLPermissionGroupStatusMixed;
+
+                        testFilter.rpcPermissionStatusHandler(testObserverChangedDict, testObserverGroupStatus);
+                    });
+
+                    it(@"should call the changedDict correctly", ^{
+                        expect(testRPCPermissionStatusReturnChangedDict).to(equal(testObserverChangedDict));
+                    });
+
+                    it(@"should call the status correctly", ^{
+                        expect(@(testObserverGroupStatus)).to(equal(@(testObserverGroupStatus)));
+                    });
                 });
             });
         });
@@ -113,7 +187,7 @@ describe(@"A filter", ^{
         __block SDLPermissionFilter *testCopiedFilter = nil;
 
         beforeEach(^{
-            testFilter = [SDLPermissionFilter filterWithRPCNames:@[testPermissionElement1] groupType:SDLPermissionGroupTypeAny observer:^(NSDictionary<SDLPermissionElement *,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {} rpcPermissionStatusHandler:nil];
+            testFilter = [SDLPermissionFilter filterWithRPCNames:@[testPermissionElement1] groupType:SDLPermissionGroupTypeAny permissionsHandler:^(NSDictionary<SDLPermissionElement *,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {} rpcPermissionStatusHandler:nil];
             testCopiedFilter = [testFilter copy];
         });
 
@@ -140,10 +214,10 @@ describe(@"A filter", ^{
         __block SDLPermissionFilter *testDifferentFilter = nil;
 
         beforeEach(^{
-            testSameFilter1 = [SDLPermissionFilter filterWithRPCNames:@[testPermissionElement1] groupType:SDLPermissionGroupTypeAny observer:^(NSDictionary<SDLPermissionElement *,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {} rpcPermissionStatusHandler:nil];
+            testSameFilter1 = [SDLPermissionFilter filterWithRPCNames:@[testPermissionElement1] groupType:SDLPermissionGroupTypeAny permissionsHandler:^(NSDictionary<SDLPermissionElement *,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {} rpcPermissionStatusHandler:nil];
             testSameFilter2 = [testSameFilter1 copy];
 
-            testDifferentFilter = [SDLPermissionFilter filterWithRPCNames:@[testPermissionElement1] groupType:SDLPermissionGroupTypeAny observer:^(NSDictionary<SDLPermissionElement *,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {} rpcPermissionStatusHandler:nil];
+            testDifferentFilter = [SDLPermissionFilter filterWithRPCNames:@[testPermissionElement1] groupType:SDLPermissionGroupTypeAny permissionsHandler:^(NSDictionary<SDLPermissionElement *,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {} rpcPermissionStatusHandler:nil];
         });
 
         it(@"should say copied filters are the same", ^{
diff --git a/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionsManagerSpec.m b/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionsManagerSpec.m
index bfcb9a3eb..e0fedfadf 100644
--- a/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionsManagerSpec.m
+++ b/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionsManagerSpec.m
@@ -26,7 +26,7 @@
 
 QuickSpecBegin(SDLPermissionsManagerSpec)
 
-fdescribe(@"SDLPermissionsManager", ^{
+describe(@"SDLPermissionsManager", ^{
     __block SDLPermissionManager *testPermissionsManager = nil;
 
     __block NSString *testRPCNameAllAllowed = nil;
@@ -67,12 +67,6 @@ fdescribe(@"SDLPermissionsManager", ^{
     __block SDLPermissionElement *testPermissionElementFullLimitedAllowed = nil;
     __block SDLPermissionElement *testPermissionElementDisallowed = nil;
 
-    __block NSDictionary *testAllowedDict = nil;
-    __block SDLRPCPermissionStatus *testAllowedStatus = nil;
-
-    __block NSDictionary *testDisallowedDict = nil;
-    __block SDLRPCPermissionStatus *testDisallowedStatus = nil;
-
     beforeEach(^{
         // Permission Names
         testRPCNameAllAllowed = @"AllAllowed";
@@ -161,12 +155,6 @@ fdescribe(@"SDLPermissionsManager", ^{
         testPermissionElementAllAllowed = [[SDLPermissionElement alloc] initWithRPCName:testRPCNameAllAllowed parameterPermissions:@[testRPCParameterNameAllAllowed]];
         testPermissionElementFullLimitedAllowed = [[SDLPermissionElement alloc] initWithRPCName:testRPCNameFullLimitedAllowed parameterPermissions:@[testRPCParameterNameFullLimitedAllowed]];
         testPermissionElementDisallowed = [[SDLPermissionElement alloc] initWithRPCName:testRPCNameAllDisallowed    parameterPermissions:@[testRPCParameterNameAllDisallowed]];
-
-        testAllowedDict = [[NSDictionary alloc] initWithObjectsAndKeys:@(0),testRPCParameterNameAllAllowed, nil];
-        testAllowedStatus = [[SDLRPCPermissionStatus alloc] initWithRPCName:testPermissionElementAllAllowed.rpcName isRPCAllowed:YES allowedParameters:testAllowedDict];
-
-        testDisallowedDict = [[NSDictionary alloc] initWithObjectsAndKeys:@(0),testRPCParameterNameAllDisallowed, nil];
-        testDisallowedStatus = [[SDLRPCPermissionStatus alloc] initWithRPCName:testPermissionElementDisallowed.rpcName isRPCAllowed:YES allowedParameters:testDisallowedDict];
     });
 
     it(@"should clear when stopped", ^{
@@ -426,6 +414,11 @@ fdescribe(@"SDLPermissionsManager", ^{
         __block SDLRPCPermissionStatus *allowedResultStatus = nil;
         __block SDLRPCPermissionStatus *disallowedResultStatus = nil;
 
+        __block NSDictionary *testAllowedDict = nil;
+        __block SDLRPCPermissionStatus *testAllowedStatus = nil;
+        __block NSDictionary *testDisallowedDict = nil;
+        __block SDLRPCPermissionStatus *testDisallowedStatus = nil;
+
         context(@"with no permissions data", ^{
             context(@"deprecated statusOfRPCs: method", ^{
                 beforeEach(^{
@@ -446,15 +439,20 @@ fdescribe(@"SDLPermissionsManager", ^{
                     testResultRPCPermissionStatusDict = [testPermissionsManager statusesOfRPCNames:@[testPermissionElementAllAllowed, testPermissionElementDisallowed]];
                     allowedResultStatus = testResultRPCPermissionStatusDict[testPermissionElementAllAllowed.rpcName];
                     disallowedResultStatus = testResultRPCPermissionStatusDict[testPermissionElementDisallowed.rpcName];
+
+                    testAllowedDict = [[NSDictionary alloc] initWithObjectsAndKeys:@(0), testRPCParameterNameAllAllowed, nil];
+                    testAllowedStatus = [[SDLRPCPermissionStatus alloc] initWithRPCName:testPermissionElementAllAllowed.rpcName isRPCAllowed:YES rpcParameters:testAllowedDict];
+                    testDisallowedDict = [[NSDictionary alloc] initWithObjectsAndKeys:@(0), testRPCParameterNameAllDisallowed, nil];
+                    testDisallowedStatus = [[SDLRPCPermissionStatus alloc] initWithRPCName:testPermissionElementDisallowed.rpcName isRPCAllowed:YES rpcParameters:testDisallowedDict];
                 });
 
-                it(@"should return correct permission statuses", ^{
+                it(@"should return the correct permission statuses", ^{
                     expect(allowedResultStatus.rpcName).to(equal(testAllowedStatus.rpcName));
-                    expect(allowedResultStatus.allowedParameters).to(equal(testAllowedStatus.allowedParameters));
+                    expect(allowedResultStatus.rpcParameters).to(equal(testAllowedStatus.rpcParameters));
                     expect(allowedResultStatus.rpcAllowed).to(equal(@NO));
 
                     expect(disallowedResultStatus.rpcName).to(equal(testDisallowedStatus.rpcName));
-                    expect(disallowedResultStatus.allowedParameters).to(equal(testDisallowedStatus.allowedParameters));
+                    expect(disallowedResultStatus.rpcParameters).to(equal(testDisallowedStatus.rpcParameters));
                     expect(disallowedResultStatus.rpcAllowed).to(equal(@NO));
                 });
             });
@@ -482,12 +480,26 @@ fdescribe(@"SDLPermissionsManager", ^{
                     [[NSNotificationCenter defaultCenter] postNotification:limitedHMINotification];
                     [[NSNotificationCenter defaultCenter] postNotification:testPermissionsNotification];
 
-                    testResultPermissionStatusDict = [testPermissionsManager statusesOfRPCNames:@[testPermissionElementAllAllowed, testPermissionElementDisallowed]];
+                    testResultRPCPermissionStatusDict = [testPermissionsManager statusesOfRPCNames:@[testPermissionElementAllAllowed, testPermissionElementDisallowed]];
+
+                    allowedResultStatus = testResultRPCPermissionStatusDict[testPermissionElementAllAllowed.rpcName];
+                    disallowedResultStatus = testResultRPCPermissionStatusDict[testPermissionElementDisallowed.rpcName];
+
+                    testAllowedDict = [[NSDictionary alloc] initWithObjectsAndKeys:@(1), testRPCParameterNameAllAllowed, nil];
+                    testAllowedStatus = [[SDLRPCPermissionStatus alloc] initWithRPCName:testPermissionElementAllAllowed.rpcName isRPCAllowed:YES rpcParameters:testAllowedDict];
+
+                    testDisallowedDict = [[NSDictionary alloc] initWithObjectsAndKeys:@(0), testRPCParameterNameAllDisallowed, nil];
+                    testDisallowedStatus = [[SDLRPCPermissionStatus alloc] initWithRPCName:testPermissionElementDisallowed.rpcName isRPCAllowed:NO rpcParameters:testDisallowedDict];
                 });
 
-                it(@"should return correct permission statuses", ^{
-                    expect(testResultPermissionStatusDict[testRPCNameAllAllowed]).to(equal(@YES));
-                    expect(testResultPermissionStatusDict[testRPCNameAllDisallowed]).to(equal(@NO));
+                it(@"should return the correct permission statuses", ^{
+                    expect(allowedResultStatus.rpcName).to(equal(testAllowedStatus.rpcName));
+                    expect(allowedResultStatus.rpcParameters).to(equal(testAllowedStatus.rpcParameters));
+                    expect(allowedResultStatus.rpcAllowed).to(equal(testAllowedStatus.rpcAllowed));
+
+                    expect(disallowedResultStatus.rpcName).to(equal(testDisallowedStatus.rpcName));
+                    expect(disallowedResultStatus.rpcParameters).to(equal(testDisallowedStatus.rpcParameters));
+                    expect(disallowedResultStatus.rpcAllowed).to(equal(testDisallowedStatus.rpcAllowed));
                 });
             });
         });
diff --git a/SmartDeviceLinkTests/SDLRPCPermissionStatusSpec.m b/SmartDeviceLinkTests/SDLRPCPermissionStatusSpec.m
index e01e6d32c..49a5e05bf 100644
--- a/SmartDeviceLinkTests/SDLRPCPermissionStatusSpec.m
+++ b/SmartDeviceLinkTests/SDLRPCPermissionStatusSpec.m
@@ -29,7 +29,7 @@ describe(@"A rpc permission status", ^{
         __block SDLRPCPermissionStatus *testSDLRPCPermissionStatusSpec = nil;
 
         beforeEach(^{
-            testSDLRPCPermissionStatusSpec = [[SDLRPCPermissionStatus alloc] initWithRPCName:testRPCName isRPCAllowed:isRPCAllowed allowedParameters:allowedParameters];
+            testSDLRPCPermissionStatusSpec = [[SDLRPCPermissionStatus alloc] initWithRPCName:testRPCName isRPCAllowed:isRPCAllowed rpcParameters:allowedParameters];
         });
 
         it(@"should set the rpcName correctly", ^{
@@ -41,7 +41,7 @@ describe(@"A rpc permission status", ^{
         });
 
         it(@"should set the parameter permissions correctly", ^{
-            expect(testSDLRPCPermissionStatusSpec.allowedParameters[testParameterName]).to(equal(@NO));
+            expect(testSDLRPCPermissionStatusSpec.rpcParameters[testParameterName]).to(equal(@NO));
         });
     });
 });