summaryrefslogtreecommitdiff
path: root/SmartDeviceLinkTests/DevAPISpecs/SDLPermissionFilterSpec.m
blob: ccbf6bb34d0e796584f9afd9a73fbd9d05ff8364 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#import <Quick/Quick.h>
#import <Nimble/Nimble.h>

#import "SDLPermissionConstants.h"
#import "SDLPermissionFilter.h"

QuickSpecBegin(SDLPermissionFilterSpec)

describe(@"A filter", ^{
    __block NSString *testRPCName1 = nil;
    __block NSString *testRPCName2 = nil;
    
    beforeEach(^{
        testRPCName1 = @"testRPCName1";
        testRPCName2 = @"testRPCName2";
    });
    
    describe(@"should initialize correctly", ^{
        __block NSArray<SDLPermissionRPCName> *testRPCNames = nil;
        __block SDLPermissionGroupType testGroupType = SDLPermissionGroupTypeAny;
        __block SDLPermissionFilter *testFilter = nil;
        
        __block NSDictionary<SDLPermissionRPCName, NSNumber<SDLBool> *> *testObserverReturnChangedDict = nil;
        
        beforeEach(^{
            testRPCNames = @[testRPCName1, testRPCName2];
            testGroupType = SDLPermissionGroupTypeAny;
        });
        
        context(@"using initWithRPCNames:changeType:observer:", ^{
            beforeEach(^{
                testFilter = [[SDLPermissionFilter alloc] initWithRPCNames:testRPCNames groupType:testGroupType observer:^(NSDictionary<SDLPermissionRPCName,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {
                    testObserverReturnChangedDict = changedDict;
                }];
            });
            
            it(@"should set the rpcNames array correctly", ^{
                expect(testFilter.rpcNames).to(equal(testRPCNames));
            });
            
            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(@"using filterWithRPCNames:changeType:observer:", ^{
            beforeEach(^{
                testFilter = [SDLPermissionFilter filterWithRPCNames:testRPCNames groupType:testGroupType observer:^(NSDictionary<SDLPermissionRPCName,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {
                    testObserverReturnChangedDict = changedDict;
                }];
            });
            
            it(@"should set the rpcNames array correctly", ^{
                expect(testFilter.rpcNames).to(equal(testRPCNames));
            });
            
            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)));
                });
            });
        });
    });
    
    describe(@"copying a filter", ^{
        __block SDLPermissionFilter *testFilter = nil;
        __block SDLPermissionFilter *testCopiedFilter = nil;
        
        beforeEach(^{
            testFilter = [SDLPermissionFilter filterWithRPCNames:@[testRPCName1] groupType:SDLPermissionGroupTypeAny observer:^(NSDictionary<SDLPermissionRPCName,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {}];
            testCopiedFilter = [testFilter copy];
        });
        
        it(@"should say copied filters are not the same instance", ^{
            expect(testCopiedFilter).toNot(beIdenticalTo(testFilter));
        });
        
        it(@"should copy the identifier correctly", ^{
            expect(testCopiedFilter.identifier).to(equal(testFilter.identifier));
        });
        
        it(@"should copy the filter array correctly", ^{
            expect(testCopiedFilter.rpcNames).to(equal(testFilter.rpcNames));
        });
        
        it(@"should copy the change type correctly", ^{
            expect(@(testCopiedFilter.groupType)).to(equal(@(testFilter.groupType)));
        });
        
        it(@"should copy the observer correctly", ^{
            expect(testCopiedFilter.handler).to(equal(testFilter.handler));
        });
    });
    
    describe(@"testing equality", ^{
        __block SDLPermissionFilter *testSameFilter1 = nil;
        __block SDLPermissionFilter *testSameFilter2 = nil;
        __block SDLPermissionFilter *testDifferentFilter = nil;
        
        beforeEach(^{
            testSameFilter1 = [SDLPermissionFilter filterWithRPCNames:@[testRPCName1] groupType:SDLPermissionGroupTypeAny observer:^(NSDictionary<SDLPermissionRPCName,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {}];
            testSameFilter2 = [testSameFilter1 copy];
            
            testDifferentFilter = [SDLPermissionFilter filterWithRPCNames:@[testRPCName1] groupType:SDLPermissionGroupTypeAny observer:^(NSDictionary<SDLPermissionRPCName,NSNumber<SDLBool> *> * _Nonnull changedDict, SDLPermissionGroupStatus status) {}];
        });
        
        it(@"should say copied filters are the same", ^{
            expect(testSameFilter1).to(equal(testSameFilter2));
        });
        
        it(@"should say new filters are different", ^{
            expect(testSameFilter1).toNot(equal(testDifferentFilter));
        });
    });
});

QuickSpecEnd