Merge pull request #14 from jzucker2/develop

Unified Cassette subclasses into a single class

BeKindRewind.podspec

@@ -8,7 +8,7 @@
 
 Pod::Spec.new do |s|
   s.name             = "BeKindRewind"
-  s.version          = "0.7.0"
+  s.version          = "0.7.1"
   s.summary          = "A simple way to record and replay network requests for testing."
   s.description      = <<-DESC
                         Provides an XCTestCase subclass for easily

BeKindRewind/Core/Cassette/BKRCassette+Playable.h

@@ -7,7 +7,10 @@
 //
 
 #import "BKRCassette.h"
+#import "BKRPlistSerializing.h"
 
-@interface BKRCassette (Playable)
+@interface BKRCassette (Playable) <BKRPlistDeserializer>
+
++ (instancetype)cassetteFromDictionary:(NSDictionary *)dictionary;
 
 @end

BeKindRewind/Core/Cassette/BKRCassette+Playable.m

@@ -7,7 +7,31 @@
 //
 
 #import "BKRCassette+Playable.h"
+#import "BKRScene+Playable.h"
+#import "BKRConstants.h"
 
 @implementation BKRCassette (Playable)
 
++ (instancetype)cassetteFromDictionary:(NSDictionary *)dictionary {
+    return [[self alloc] initFromPlistDictionary:dictionary];
+}
+
+- (instancetype)initFromPlistDictionary:(NSDictionary *)dictionary {
+    self = [[[self class] alloc] init];
+    if (self) {
+        self.creationDate = dictionary[@"creationDate"];
+        [self _addEditedScenes:dictionary[@"scenes"]];
+    }
+    return self;
+}
+
+- (void)_addEditedScenes:(NSArray<NSDictionary *> *)rawScenes {
+    BKRWeakify(self);
+    dispatch_apply(rawScenes.count, self.processingQueue, ^(size_t iteration) {
+        BKRStrongify(self);
+        BKRScene *scene = [[BKRScene alloc] initFromPlistDictionary:rawScenes[iteration]];
+        [self addSceneToScenesDictionary:scene];
+    });
+}
+
 @end

BeKindRewind/Core/Cassette/BKRCassette+Recordable.h

@@ -7,7 +7,28 @@
 //
 
 #import "BKRCassette.h"
+#import "BKRPlistSerializing.h"
+#import "BKRConstants.h"
 
-@interface BKRCassette (Recordable)
+@class BKRRawFrame;
+
+@interface BKRCassette (Recordable) <BKRPlistSerializer>
+
+/**
+ *  Add pieces of network requests to this cassette. Cassette will combine
+ *  these "frames" into full scenes.
+ *
+ *  @param frame piece of a network request that needs to be grouped into a BRKScene
+ */
+- (void)addFrame:(BKRRawFrame *)frame;
+
+/**
+ *  This executes on the main queue after adding all frames for a particular scene/network
+ *  task to a cassette for grouping into scenes.
+ *
+ *  @param endTaskBlock block to execute after all frames are added for a NSURLSessionTask. This will execute after every single network request if it is not nil.
+ *  @param task         NSURLSessionTask that just finished recording
+ */
+- (void)executeEndTaskRecordingBlock:(BKREndRecordingTaskBlock)endTaskBlock withTask:(NSURLSessionTask *)task;
 
 @end

BeKindRewind/Core/Cassette/BKRCassette+Recordable.m

@@ -7,7 +7,51 @@
 //
 
 #import "BKRCassette+Recordable.h"
+#import "BKRRawFrame+Recordable.h"
+#import "BKRScene+Recordable.h"
 
 @implementation BKRCassette (Recordable)
 
+// frames and scenes share unique identifiers, this comes from the recorded task
+// if the frame matches a scene unique identifier, then add it to the scene
+- (void)addFrame:(BKRRawFrame *)frame {
+    if (!frame.item) {
+        // Can't add a blank frame!
+        return;
+    }
+    NSParameterAssert(frame);
+    BKRWeakify(self);
+    dispatch_barrier_async(self.processingQueue, ^{
+        BKRStrongify(self);
+        NSDictionary *currentDictionary = self.scenesDictionary;
+        if (currentDictionary[frame.uniqueIdentifier]) {
+            BKRScene *existingScene = currentDictionary[frame.uniqueIdentifier];
+            [existingScene addFrame:frame];
+        } else {
+            BKRScene *newScene = [BKRScene sceneFromFrame:frame];
+            [self addSceneToScenesDictionary:newScene];
+        }
+    });
+}
+
+- (void)executeEndTaskRecordingBlock:(BKREndRecordingTaskBlock)endTaskBlock withTask:(NSURLSessionTask *)task {
+    dispatch_barrier_async(self.processingQueue, ^{
+        dispatch_async(dispatch_get_main_queue(), ^{
+            endTaskBlock(task);
+        });
+    });
+}
+
+- (NSDictionary *)plistDictionary {
+    NSMutableArray *plistArray = [NSMutableArray array];
+    for (BKRScene *scene in self.allScenes) {
+        [plistArray addObject:scene.plistDictionary];
+    }
+    NSMutableDictionary *plistDict = [@{
+                                        @"scenes": [[NSArray alloc] initWithArray:plistArray copyItems:YES]
+                                        } mutableCopy];
+    plistDict[@"creationDate"] = self.creationDate.copy;
+    return [[NSDictionary alloc] initWithDictionary:plistDict copyItems:YES];
+}
+
 @end

BeKindRewind/Core/Cassette/BKRCassette.h

@@ -15,6 +15,8 @@
  */
 @interface BKRCassette : NSObject
 
++ (instancetype)cassette;
+
 /**
  *  Date when this recording session is first created
  */

BeKindRewind/Core/Cassette/BKRCassette.m

@@ -18,6 +18,10 @@ @interface BKRCassette ()
 
 @implementation BKRCassette
 
++ (instancetype)cassette {
+    return [[self alloc] init];
+}
+
 - (instancetype)init {
     self = [super init];
     if (self) {

BeKindRewind/Core/Editor/BKREditor.h

@@ -32,6 +32,7 @@
 
 - (void)setEnabled:(BOOL)enabled withCompletionHandler:(BKRCassetteEditingBlock)editingBlock;
 - (void)editCassette:(BKRCassetteEditingBlock)cassetteEditingBlock;
+- (void)editCassetteSynchronously:(BKRCassetteEditingBlock)cassetteEditingBlock;
 
 /**
  *  Separate queue for processing editing actions

BeKindRewind/Core/Editor/BKREditor.m

@@ -30,16 +30,6 @@ + (instancetype)editor {
 }
 
 - (void)setEnabled:(BOOL)enabled withCompletionHandler:(BKRCassetteEditingBlock)editingBlock {
-//    BKRWeakify(self);
-//    dispatch_barrier_async(self.editingQueue, ^{
-//        BKRStrongify(self);
-//        self->_enabled = enabled;
-//        if (completionBlock) {
-//            dispatch_async(dispatch_get_main_queue(), ^{
-//                completionBlock();
-//            });
-//        }
-//    });
     BKRWeakify(self);
     dispatch_barrier_async(self.editingQueue, ^{
         BKRStrongify(self);
@@ -61,6 +51,17 @@ - (void)editCassette:(BKRCassetteEditingBlock)cassetteEditingBlock {
     });
 }
 
+- (void)editCassetteSynchronously:(BKRCassetteEditingBlock)cassetteEditingBlock {
+    if (!cassetteEditingBlock) {
+        return;
+    }
+    BKRWeakify(self);
+    dispatch_barrier_sync(self.editingQueue, ^{
+        BKRStrongify(self);
+        cassetteEditingBlock(self->_enabled, self->_currentCassette);
+    });
+}
+
 - (void)setEnabled:(BOOL)enabled {
     [self setEnabled:enabled withCompletionHandler:nil];
 }