diff --git a/src/Lunr/Vortex/FCM/FCMBatchResponse.php b/src/Lunr/Vortex/FCM/FCMBatchResponse.php
new file mode 100644
index 0000000000000000000000000000000000000000..10f044d092b8a1a00437c2bf2dfdf814df5eed92
--- /dev/null
+++ b/src/Lunr/Vortex/FCM/FCMBatchResponse.php
@@ -0,0 +1,246 @@
+<?php
+
+/**
+ * This file contains the FCMBatchResponse class.
+ *
+ * PHP Version 5.4
+ *
+ * @package    Lunr\Vortex\FCM
+ * @author     Patrick Valk <p.valk@m2mobi.com>
+ * @copyright  2016, M2Mobi BV, Amsterdam, The Netherlands
+ * @license    http://lunr.nl/LICENSE MIT License
+ */
+
+namespace Lunr\Vortex\FCM;
+
+use Lunr\Vortex\PushNotificationStatus;
+
+/**
+ * FCM response for a batch push notification.
+ */
+class FCMBatchResponse
+{
+
+    /**
+     * Shared instance of a Logger class.
+     * @var LoggerInterface
+     */
+    private $logger;
+
+    /**
+     * The response HTTP code.
+     * @var Integer
+     */
+    private $http_code;
+
+    /**
+     * The response body content.
+     * @var String
+     */
+    private $content;
+
+    /**
+     * The statuses per endpoint.
+     * @var Array
+     */
+    private $statuses;
+
+    /**
+     * Constructor.
+     *
+     * @param \Requests_Response       $response  Requests_Response object.
+     * @param \Psr\Log\LoggerInterface $logger    Shared instance of a Logger.
+     * @param Array                    $endpoints The endpoints the message was sent to (in the same order as sent).
+     */
+    public function __construct($response, $logger, $endpoints)
+    {
+        $this->logger   = $logger;
+        $this->statuses = [];
+
+        $this->http_code = $response->status_code;
+        $this->content   = $response->body;
+
+        if ($this->http_code == 200)
+        {
+            $this->set_statuses($endpoints);
+        }
+        else
+        {
+            $this->report_error($endpoints);
+        }
+    }
+
+    /**
+     * Destructor.
+     */
+    public function __destruct()
+    {
+        unset($this->logger);
+        unset($this->http_code);
+        unset($this->content);
+        unset($this->statuses);
+    }
+
+    /**
+     * Define the status result for each endpoint.
+     *
+     * @param Array $endpoints The endpoints the message was sent to (in the same order as sent).
+     *
+     * @return void
+     */
+    private function set_statuses(&$endpoints)
+    {
+        $json_content = json_decode($this->content, TRUE);
+
+        if (!isset($json_content['results']))
+        {
+            $this->report_error($endpoints);
+            return;
+        }
+
+        foreach ($json_content['results'] as $result)
+        {
+            $endpoint = array_shift($endpoints);
+
+            if (is_null($endpoint))
+            {
+                break;
+            }
+
+            if (!isset($result['error']))
+            {
+                $this->statuses[$endpoint] = PushNotificationStatus::SUCCESS;
+            }
+            else
+            {
+                $this->report_endpoint_error($endpoint, $result['error']);
+            }
+
+            // We are supposed here to parse the new registration ids
+        }
+    }
+
+    /**
+     * Get notification delivery status for an endpoint.
+     *
+     * @param String $endpoint endpoint
+     *
+     * @return PushNotificationStatus $status Delivery status for the endpoint
+     */
+    public function get_status($endpoint)
+    {
+        return isset($this->statuses[$endpoint]) ? $this->statuses[$endpoint] : PushNotificationStatus::UNKNOWN;
+    }
+
+    /**
+     * Report an error with the push notification.
+     *
+     * @param Array $endpoints The endpoints the message was sent to
+     *
+     * @return void
+     */
+    private function report_error(&$endpoints)
+    {
+        $error_message = 'Unknown error';
+        $status        = PushNotificationStatus::UNKNOWN;
+
+        if ($this->http_code == 400)
+        {
+            $error_message = "Invalid JSON ({$this->content})";
+            $status        = PushNotificationStatus::ERROR;
+        }
+        else if ($this->http_code == 401)
+        {
+            $error_message = 'Error with authentication';
+            $status        = PushNotificationStatus::ERROR;
+        }
+        else if ($this->http_code >= 500)
+        {
+            $error_message = 'Internal error';
+            $status        = PushNotificationStatus::TEMPORARY_ERROR;
+        }
+
+        foreach ($endpoints as $endpoint)
+        {
+            $this->statuses[$endpoint] = $status;
+        }
+
+        $context = [ 'error' => $error_message ];
+        $this->logger->warning('Dispatching push notification failed: {error}', $context);
+    }
+
+    /**
+     * Report an error with the push notification for one endpoint.
+     *
+     * @param String $endpoint   Endpoint for which the push failed
+     * @param String $error_code Error responde code
+     *
+     * @return void
+     */
+    private function report_endpoint_error($endpoint, $error_code)
+    {
+        switch ($error_code)
+        {
+            case 'MissingRegistration':
+                $status        = PushNotificationStatus::INVALID_ENDPOINT;
+                $error_message = 'Missing registration token';
+                break;
+            case 'InvalidRegistration':
+                $status        = PushNotificationStatus::INVALID_ENDPOINT;
+                $error_message = 'Invalid registration token';
+                break;
+            case 'NotRegistered':
+                $status        = PushNotificationStatus::INVALID_ENDPOINT;
+                $error_message = 'Unregistered device';
+                break;
+            case 'InvalidPackageName':
+                $status        = PushNotificationStatus::INVALID_ENDPOINT;
+                $error_message = 'Invalid package name';
+                break;
+            case 'MismatchSenderId':
+                $status        = PushNotificationStatus::INVALID_ENDPOINT;
+                $error_message = 'Mismatched sender';
+                break;
+            case 'MessageTooBig':
+                $status        = PushNotificationStatus::ERROR;
+                $error_message = 'Message too big';
+                break;
+            case 'InvalidDataKey':
+                $status        = PushNotificationStatus::ERROR;
+                $error_message = 'Invalid data key';
+                break;
+            case 'InvalidTtl':
+                $status        = PushNotificationStatus::ERROR;
+                $error_message = 'Invalid time to live';
+                break;
+            case 'Unavailable':
+                $status        = PushNotificationStatus::TEMPORARY_ERROR;
+                $error_message = 'Timeout';
+                break;
+            case 'InternalServerError':
+                $status        = PushNotificationStatus::TEMPORARY_ERROR;
+                $error_message = 'Internal server error';
+                break;
+            case 'DeviceMessageRateExceeded':
+                $status        = PushNotificationStatus::TEMPORARY_ERROR;
+                $error_message = 'Device message rate exceeded';
+                break;
+            case 'TopicsMessageRateExceeded':
+                $status        = PushNotificationStatus::TEMPORARY_ERROR;
+                $error_message = 'Topics message rate exceeded';
+                break;
+            default:
+                $status        = PushNotificationStatus::UNKNOWN;
+                $error_message = $error_code;
+                break;
+        }
+
+        $context = [ 'endpoint' => $endpoint, 'error' => $error_message ];
+        $this->logger->warning('Dispatching push notification failed for endpoint {endpoint}: {error}', $context);
+
+        $this->statuses[$endpoint] = $status;
+    }
+
+}
+
+?>
diff --git a/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseBasePushErrorTest.php b/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseBasePushErrorTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..bb16e681fc2c1cf94a800caae0865172d55e8ecb
--- /dev/null
+++ b/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseBasePushErrorTest.php
@@ -0,0 +1,184 @@
+<?php
+
+/**
+ * This file contains the FCMBatchResponseBasePushErrorTest class.
+ *
+ * PHP Version 5.4
+ *
+ * @package    Lunr\Vortex\FCM
+ * @author     Patrick Valk <p.valk@m2mobi.com>
+ * @copyright  2016, M2Mobi BV, Amsterdam, The Netherlands
+ * @license    http://lunr.nl/LICENSE MIT License
+ */
+
+namespace Lunr\Vortex\FCM\Tests;
+
+use Lunr\Vortex\FCM\FCMBatchResponse;
+use Lunr\Vortex\PushNotificationStatus;
+
+use ReflectionClass;
+
+/**
+ * This class contains tests for the constructor of the FCMBatchResponse class
+ * in case of a push notification error.
+ *
+ * @covers Lunr\Vortex\FCM\FCMBatchResponse
+ */
+class FCMBatchResponseBasePushErrorTest extends FCMBatchResponseTest
+{
+
+    /**
+     * Test constructor behavior for error of push notification in case of invalid JSON.
+     *
+     * @covers Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushErrorInvalidJSON()
+    {
+        $http_code = 400;
+        $content   = 'Field "collapse_key" must be a JSON string: 1463565451';
+
+        $this->response->status_code = $http_code;
+        $this->response->body        = $content;
+
+        $this->logger->expects($this->once())
+                     ->method('warning')
+                     ->with(
+                        'Dispatching push notification failed: {error}',
+                        [ 'error' => "Invalid JSON ({$content})" ]
+                     );
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, [ 'endpoint1' ]);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger);
+        $this->assertPropertyEquals('statuses', [ 'endpoint1' => PushNotificationStatus::ERROR ]);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', $http_code);
+    }
+
+    /**
+     * Test constructor behavior for error of push notification in case of authentication error.
+     *
+     * @covers Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushErrorAuthenticationError()
+    {
+        $http_code = 401;
+        $content   = 'stuff';
+
+        $this->response->status_code = $http_code;
+        $this->response->body        = $content;
+
+        $this->logger->expects($this->once())
+                     ->method('warning')
+                     ->with(
+                        'Dispatching push notification failed: {error}',
+                        [ 'error' => 'Error with authentication' ]
+                     );
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, [ 'endpoint1' ]);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger);
+        $this->assertPropertyEquals('statuses', [ 'endpoint1' => PushNotificationStatus::ERROR ]);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', $http_code);
+    }
+
+    /**
+     * Unit test data provider for internal error http codes.
+     *
+     * @return Array $data http code
+     */
+    public function internalErrorHTTPCodeDataProvider()
+    {
+        $data = [];
+
+        $data[] = [ 500 ];
+        $data[] = [ 501 ];
+        $data[] = [ 503 ];
+        $data[] = [ 599 ];
+
+        return $data;
+    }
+
+    /**
+     * Test constructor behavior for error of push notification in case of internal error.
+     *
+     * @param Integer $http_code HTTP code received
+     *
+     * @dataProvider internalErrorHTTPCodeDataProvider
+     * @covers       Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushErrorInternalError($http_code)
+    {
+        $content = 'stuff';
+
+        $this->response->status_code = $http_code;
+        $this->response->body        = $content;
+
+        $this->logger->expects($this->once())
+                     ->method('warning')
+                     ->with(
+                        'Dispatching push notification failed: {error}',
+                        [ 'error' => 'Internal error' ]
+                     );
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, [ 'endpoint1' ]);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger);
+        $this->assertPropertyEquals('statuses', [ 'endpoint1' => PushNotificationStatus::TEMPORARY_ERROR ]);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', $http_code);
+    }
+
+    /**
+     * Unit test data provider for unknown error http codes.
+     *
+     * @return Array $data http code
+     */
+    public function unknownErrorHTTPCodeDataProvider()
+    {
+        $data = [];
+
+        $data[] = [ 404 ];
+        $data[] = [ 403 ];
+
+        return $data;
+    }
+
+    /**
+     * Test constructor behavior for error of push notification in case of unknown error.
+     *
+     * @param Integer $http_code HTTP code received
+     *
+     * @dataProvider unknownErrorHTTPCodeDataProvider
+     * @covers       Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushErrorUnknownError($http_code)
+    {
+        $content = 'stuff';
+
+        $this->response->status_code = $http_code;
+        $this->response->body        = $content;
+
+        $this->logger->expects($this->once())
+                     ->method('warning')
+                     ->with(
+                        'Dispatching push notification failed: {error}',
+                        [ 'error' => 'Unknown error' ]
+                     );
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, [ 'endpoint1' ]);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger);
+        $this->assertPropertyEquals('statuses', [ 'endpoint1' => PushNotificationStatus::UNKNOWN ]);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', $http_code);
+    }
+
+}
+
+?>
diff --git a/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseBasePushSuccessTest.php b/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseBasePushSuccessTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..b60b2035af4567f5a76113d3671f50ea3646b396
--- /dev/null
+++ b/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseBasePushSuccessTest.php
@@ -0,0 +1,323 @@
+<?php
+
+/**
+ * This file contains the FCMBatchResponseBasePushSuccessTest class.
+ *
+ * PHP Version 5.4
+ *
+ * @package    Lunr\Vortex\FCM
+ * @author     Patrick Valk <p.valk@m2mobi.com>
+ * @copyright  2016, M2Mobi BV, Amsterdam, The Netherlands
+ * @license    http://lunr.nl/LICENSE MIT License
+ */
+
+namespace Lunr\Vortex\FCM\Tests;
+
+use Lunr\Vortex\FCM\FCMBatchResponse;
+use Lunr\Vortex\PushNotificationStatus;
+
+use ReflectionClass;
+
+/**
+ * This class contains tests for the constructor of the FCMBatchResponse class
+ * in case of a push notification success.
+ *
+ * @covers Lunr\Vortex\FCM\FCMBatchResponse
+ */
+class FCMBatchResponseBasePushSuccessTest extends FCMBatchResponseTest
+{
+
+    /**
+     * Test constructor behavior for success of push notification with missing results.
+     *
+     * @covers Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushSuccessWithMissingResults()
+    {
+        $content = file_get_contents(TEST_STATICS . '/Vortex/fcm/response_missing_results.json');
+
+        $this->response->status_code = 200;
+        $this->response->body        = $content;
+
+        $this->logger->expects($this->once())
+                     ->method('warning')
+                     ->with(
+                        'Dispatching push notification failed: {error}',
+                        [ 'error' => 'Unknown error' ]
+                     );
+
+        $endpoints = [ 'endpoint1' ];
+        $statuses  = [ 'endpoint1' => PushNotificationStatus::UNKNOWN ];
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, $endpoints);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger, $endpoints);
+        $this->assertPropertyEquals('statuses', $statuses);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', 200);
+    }
+
+    /**
+     * Test constructor behavior for push success with single endpoint success.
+     *
+     * @covers Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushSuccessWithSingleSuccess()
+    {
+        $content = file_get_contents(TEST_STATICS . '/Vortex/fcm/response_single_success.json');
+
+        $this->response->status_code = 200;
+        $this->response->body        = $content;
+
+        $this->logger->expects($this->never())
+                     ->method('warning');
+
+        $endpoints = [ 'endpoint1' ];
+        $statuses  = [ 'endpoint1' => PushNotificationStatus::SUCCESS ];
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, $endpoints);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger, $endpoints);
+        $this->assertPropertyEquals('statuses', $statuses);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', 200);
+    }
+
+    /**
+     * Test constructor behavior for success of push notification with single error.
+     *
+     * @covers Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushSuccessWithSingleError()
+    {
+        $content = file_get_contents(TEST_STATICS . '/Vortex/fcm/response_single_error.json');
+
+        $this->response->status_code = 200;
+        $this->response->body        = $content;
+
+        $this->logger->expects($this->once())
+                     ->method('warning')
+                     ->with(
+                        'Dispatching push notification failed for endpoint {endpoint}: {error}',
+                        [ 'endpoint' => 'endpoint1', 'error' => 'Invalid registration token' ]
+                     );
+
+        $endpoints = [ 'endpoint1' ];
+        $statuses  = [ 'endpoint1' => PushNotificationStatus::INVALID_ENDPOINT ];
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, $endpoints);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger, $endpoints);
+        $this->assertPropertyEquals('statuses', $statuses);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', 200);
+    }
+
+    /**
+     * Test constructor behavior for success of push notification with multiple success.
+     *
+     * @covers Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushSuccessWithMultipleSuccess()
+    {
+        $content = file_get_contents(TEST_STATICS . '/Vortex/fcm/response_multiple_success.json');
+
+        $this->response->status_code = 200;
+        $this->response->body        = $content;
+
+        $this->logger->expects($this->never())
+                     ->method('warning');
+
+        $endpoints = [ 'endpoint1', 'endpoint2', 'endpoint3' ];
+        $statuses  = [
+            'endpoint1' => PushNotificationStatus::SUCCESS,
+            'endpoint2' => PushNotificationStatus::SUCCESS,
+            'endpoint3' => PushNotificationStatus::SUCCESS,
+        ];
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, $endpoints);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger, $endpoints);
+        $this->assertPropertyEquals('statuses', $statuses);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', 200);
+    }
+
+    /**
+     * Test constructor behavior for success of push notification with multiple errors.
+     *
+     * @covers Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushSuccessWithMultipleErrors()
+    {
+        $content = file_get_contents(TEST_STATICS . '/Vortex/fcm/response_multiple_error.json');
+
+        $this->response->status_code = 200;
+        $this->response->body        = $content;
+
+        $error_messages = [
+            'endpoint1'  => 'Missing registration token',
+            'endpoint2'  => 'Invalid registration token',
+            'endpoint3'  => 'Unregistered device',
+            'endpoint4'  => 'Invalid package name',
+            'endpoint5'  => 'Mismatched sender',
+            'endpoint6'  => 'Message too big',
+            'endpoint7'  => 'Invalid data key',
+            'endpoint8'  => 'Invalid time to live',
+            'endpoint9'  => 'Timeout',
+            'endpoint10' => 'Internal server error',
+            'endpoint11' => 'Device message rate exceeded',
+            'endpoint12' => 'Topics message rate exceeded',
+            'endpoint13' => 'unknown-stuff',
+        ];
+
+        $endpoints = [];
+
+        for ($i = 1; $i <= 13; $i++)
+        {
+            $endpoint = 'endpoint' . $i;
+
+            $endpoints[] = $endpoint;
+
+            $this->logger->expects($this->at($i - 1))
+                         ->method('warning')
+                         ->with(
+                            'Dispatching push notification failed for endpoint {endpoint}: {error}',
+                            [ 'endpoint' => $endpoint, 'error' => $error_messages[$endpoint] ]
+                         );
+        }
+
+        $statuses = [
+            'endpoint1'  => PushNotificationStatus::INVALID_ENDPOINT,
+            'endpoint2'  => PushNotificationStatus::INVALID_ENDPOINT,
+            'endpoint3'  => PushNotificationStatus::INVALID_ENDPOINT,
+            'endpoint4'  => PushNotificationStatus::INVALID_ENDPOINT,
+            'endpoint5'  => PushNotificationStatus::INVALID_ENDPOINT,
+            'endpoint6'  => PushNotificationStatus::ERROR,
+            'endpoint7'  => PushNotificationStatus::ERROR,
+            'endpoint8'  => PushNotificationStatus::ERROR,
+            'endpoint9'  => PushNotificationStatus::TEMPORARY_ERROR,
+            'endpoint10' => PushNotificationStatus::TEMPORARY_ERROR,
+            'endpoint11' => PushNotificationStatus::TEMPORARY_ERROR,
+            'endpoint12' => PushNotificationStatus::TEMPORARY_ERROR,
+            'endpoint13' => PushNotificationStatus::UNKNOWN,
+        ];
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, $endpoints);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger, $endpoints);
+        $this->assertPropertyEquals('statuses', $statuses);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', 200);
+    }
+
+    /**
+     * Test constructor behavior for success of push notification with multiple mixed results.
+     *
+     * @covers Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushSuccessWithMultipleMixedResults()
+    {
+        $content = file_get_contents(TEST_STATICS . '/Vortex/fcm/response_multiple_mixed.json');
+
+        $this->response->status_code = 200;
+        $this->response->body        = $content;
+
+        $endpoints = [ 'endpoint1', 'endpoint2', 'endpoint3', 'endpoint4', 'endpoint5' ];
+        $statuses  = [
+            'endpoint1' => PushNotificationStatus::INVALID_ENDPOINT,
+            'endpoint2' => PushNotificationStatus::SUCCESS,
+            'endpoint3' => PushNotificationStatus::INVALID_ENDPOINT,
+            'endpoint4' => PushNotificationStatus::SUCCESS,
+            'endpoint5' => PushNotificationStatus::SUCCESS,
+        ];
+
+        $this->logger->expects($this->at(0))
+                      ->method('warning')
+                      ->with(
+                        'Dispatching push notification failed for endpoint {endpoint}: {error}',
+                        [ 'endpoint' => 'endpoint1', 'error' => 'Invalid registration token' ]
+                      );
+
+        $this->logger->expects($this->at(1))
+                      ->method('warning')
+                      ->with(
+                        'Dispatching push notification failed for endpoint {endpoint}: {error}',
+                        [ 'endpoint' => 'endpoint3', 'error' => 'Invalid registration token' ]
+                      );
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, $endpoints);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger, $endpoints);
+        $this->assertPropertyEquals('statuses', $statuses);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', 200);
+    }
+
+    /**
+     * Test constructor behavior for success of push notification with more endpoints than results.
+     *
+     * @covers Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushSuccessWithMoreEndpointsThanResults()
+    {
+        $content = file_get_contents(TEST_STATICS . '/Vortex/fcm/response_multiple_success.json');
+
+        $this->response->status_code = 200;
+        $this->response->body        = $content;
+
+        $this->logger->expects($this->never())
+                     ->method('warning');
+
+        $endpoints = [ 'endpoint1', 'endpoint2', 'endpoint3', 'endpoint4', 'endpoint5' ];
+        $statuses  = [
+            'endpoint1' => PushNotificationStatus::SUCCESS,
+            'endpoint2' => PushNotificationStatus::SUCCESS,
+            'endpoint3' => PushNotificationStatus::SUCCESS,
+        ];
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, $endpoints);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger, $endpoints);
+        $this->assertPropertyEquals('statuses', $statuses);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', 200);
+    }
+
+    /**
+     * Test constructor behavior for success of push notification with less endpoints than results.
+     *
+     * @covers Lunr\Vortex\FCM\FCMBatchResponse::__construct
+     */
+    public function testPushSuccessWithLessEndpointsThanResults()
+    {
+        $content = file_get_contents(TEST_STATICS . '/Vortex/fcm/response_multiple_success.json');
+
+        $this->response->status_code = 200;
+        $this->response->body        = $content;
+
+        $this->logger->expects($this->never())
+                     ->method('warning');
+
+        $endpoints = [ 'endpoint1' ];
+        $statuses  = [ 'endpoint1' => PushNotificationStatus::SUCCESS ];
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, $endpoints);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+
+        $this->assertPropertySame('logger', $this->logger, $endpoints);
+        $this->assertPropertyEquals('statuses', $statuses);
+        $this->assertPropertyEquals('content', $content);
+        $this->assertPropertyEquals('http_code', 200);
+    }
+
+}
+
+?>
diff --git a/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseGetStatusTest.php b/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseGetStatusTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..772d68b37062b701aa6b625818fc4f4a01587549
--- /dev/null
+++ b/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseGetStatusTest.php
@@ -0,0 +1,114 @@
+<?php
+
+/**
+ * This file contains the FCMBatchResponseGetStatusTest class.
+ *
+ * PHP Version 5.4
+ *
+ * @package    Lunr\Vortex\FCM
+ * @author     Patrick Valk <p.valk@m2mobi.com>
+ * @copyright  2016, M2Mobi BV, Amsterdam, The Netherlands
+ * @license    http://lunr.nl/LICENSE MIT License
+ */
+
+namespace Lunr\Vortex\FCM\Tests;
+
+use Lunr\Vortex\FCM\FCMBatchResponse;
+use Lunr\Vortex\PushNotificationStatus;
+
+use ReflectionClass;
+
+/**
+ * This class contains tests for the get_status function of the FCMBatchResponse class.
+ *
+ * @covers Lunr\Vortex\FCM\FCMBatchResponse
+ */
+class FCMBatchResponseGetStatusTest extends FCMBatchResponseTest
+{
+
+    /**
+     * Testcase constructor.
+     *
+     * @return void
+     */
+    public function setUp()
+    {
+        parent::setUp();
+
+        $content = file_get_contents(TEST_STATICS . '/Vortex/fcm/response_single_success.json');
+
+        $this->response->status_code = 200;
+        $this->response->body        = $content;
+
+        $this->class      = new FCMBatchResponse($this->response, $this->logger, [ 'endpoint1' ]);
+        $this->reflection = new ReflectionClass('Lunr\Vortex\FCM\FCMBatchResponse');
+    }
+
+    /**
+     * Unit test data provider.
+     *
+     * @return Array $data array of endpoints statuses / status result
+     */
+    public function endpointDataProvider()
+    {
+        $data = [];
+
+        // return unknown status if no status set
+        $data[] = [ [], PushNotificationStatus::UNKNOWN  ];
+
+        // return unknown status if endpoint absent
+        $data[] = [
+            [
+                'endpoint1' => PushNotificationStatus::INVALID_ENDPOINT,
+            ],
+            PushNotificationStatus::UNKNOWN,
+        ];
+        $data[] = [
+            [
+                'endpoint1' => PushNotificationStatus::ERROR,
+                'endpoint2' => PushNotificationStatus::INVALID_ENDPOINT,
+                'endpoint3' => PushNotificationStatus::SUCCESS,
+            ],
+            PushNotificationStatus::UNKNOWN,
+        ];
+
+        // return endpoint own status if present
+        $data[] = [
+            [
+                'endpoint_param' => PushNotificationStatus::INVALID_ENDPOINT,
+            ],
+            PushNotificationStatus::INVALID_ENDPOINT,
+        ];
+        $data[] = [
+            [
+                'endpoint1'      => PushNotificationStatus::ERROR,
+                'endpoint_param' => PushNotificationStatus::SUCCESS,
+                'endpoint2'      => PushNotificationStatus::TEMPORARY_ERROR,
+            ],
+            PushNotificationStatus::SUCCESS,
+        ];
+
+        return $data;
+    }
+
+    /**
+     * Test the get_status() behavior.
+     *
+     * @param Array   $statuses Endpoints statuses
+     * @param Integer $status   Expected function result
+     *
+     * @dataProvider endpointDataProvider
+     * @covers       Lunr\Vortex\FCM\FCMBatchResponse::get_status
+     */
+    public function testGetStatus($statuses, $status)
+    {
+        $this->set_reflection_property_value('statuses', $statuses);
+
+        $result = $this->class->get_status('endpoint_param');
+
+        $this->assertEquals($status, $result);
+    }
+
+}
+
+?>
diff --git a/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseTest.php b/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..1e9ccaa42bb954d8489a23ce3b14dd383626ecc8
--- /dev/null
+++ b/src/Lunr/Vortex/FCM/Tests/FCMBatchResponseTest.php
@@ -0,0 +1,64 @@
+<?php
+
+/**
+ * This file contains the FCMBatchResponseTest class.
+ *
+ * PHP Version 5.4
+ *
+ * @package    Lunr\Vortex\FCM
+ * @author     Patrick Valk <p.valk@m2mobi.com>
+ * @copyright  2016, M2Mobi BV, Amsterdam, The Netherlands
+ * @license    http://lunr.nl/LICENSE MIT License
+ */
+
+namespace Lunr\Vortex\FCM\Tests;
+
+use Lunr\Halo\LunrBaseTest;
+
+/**
+ * This class contains common setup routines, providers
+ * and shared attributes for testing the FCMBatchResponse class.
+ *
+ * @covers Lunr\Vortex\FCM\FCMBatchResponse
+ */
+abstract class FCMBatchResponseTest extends LunrBaseTest
+{
+
+    /**
+     * Mock instance of the Logger class.
+     * @var \Psr\Log\LoggerInterface
+     */
+    protected $logger;
+
+    /**
+     * Mock instance of the Requests_Response class.
+     * @var \Requests_Response
+     */
+    protected $response;
+
+    /**
+     * Testcase Constructor.
+     *
+     * @return void
+     */
+    public function setUp()
+    {
+        $this->logger = $this->getMock('Psr\Log\LoggerInterface');
+
+        $this->response = $this->getMock('Requests_Response');
+    }
+
+    /**
+     * Testcase Destructor.
+     */
+    public function tearDown()
+    {
+        unset($this->logger);
+        unset($this->response);
+        unset($this->class);
+        unset($this->reflection);
+    }
+
+}
+
+?>
diff --git a/tests/phpunit.xml b/tests/phpunit.xml
index 6f9de786130590e4636f8c322db98b35c3dcd51f..ffe69372ade60fc8ebfa7b6c1ef9bc1a9fc66801 100644
--- a/tests/phpunit.xml
+++ b/tests/phpunit.xml
@@ -318,6 +318,9 @@
             <file>../src/Lunr/Vortex/FCM/Tests/FCMPayloadBaseTest.php</file>
             <file>../src/Lunr/Vortex/FCM/Tests/FCMPayloadGetTest.php</file>
             <file>../src/Lunr/Vortex/FCM/Tests/FCMPayloadSetTest.php</file>
+            <file>../src/Lunr/Vortex/FCM/Tests/FCMBatchResponseBasePushSuccessTest.php</file>
+            <file>../src/Lunr/Vortex/FCM/Tests/FCMBatchResponseBasePushErrorTest.php</file>
+            <file>../src/Lunr/Vortex/FCM/Tests/FCMBatchResponseGetStatusTest.php</file>
             <file>../src/Lunr/Vortex/MPNS/Tests/MPNSPayloadTest.php</file>
             <file>../src/Lunr/Vortex/MPNS/Tests/MPNSToastPayloadSetTest.php</file>
             <file>../src/Lunr/Vortex/MPNS/Tests/MPNSToastPayloadGetTest.php</file>
diff --git a/tests/statics/Vortex/fcm/collapse_key.json b/tests/statics/Vortex/fcm/collapse_key.json
new file mode 100644
index 0000000000000000000000000000000000000000..5654d456b63d02fcdd9303944bbcdfa20660c025
--- /dev/null
+++ b/tests/statics/Vortex/fcm/collapse_key.json
@@ -0,0 +1 @@
+{"collapse_key":"test"}
\ No newline at end of file
diff --git a/tests/statics/Vortex/fcm/data.json b/tests/statics/Vortex/fcm/data.json
new file mode 100644
index 0000000000000000000000000000000000000000..346c5271655aef3e63584539e3d414df98b7a33e
--- /dev/null
+++ b/tests/statics/Vortex/fcm/data.json
@@ -0,0 +1 @@
+{"data":{"key1":"value1","key2":"value2"}}
\ No newline at end of file
diff --git a/tests/statics/Vortex/fcm/gcm.json b/tests/statics/Vortex/fcm/gcm.json
new file mode 100644
index 0000000000000000000000000000000000000000..afb159d3129d340a274630c83c59dc006f31490a
--- /dev/null
+++ b/tests/statics/Vortex/fcm/gcm.json
@@ -0,0 +1 @@
+{"registration_ids":["one","two","three"],"collapse_key":"test","data":{"key1":"value1","key2":"value2"},"time_to_live":10}
\ No newline at end of file
diff --git a/tests/statics/Vortex/fcm/response_missing_results.json b/tests/statics/Vortex/fcm/response_missing_results.json
new file mode 100644
index 0000000000000000000000000000000000000000..a40d43536eac8bc8228b03c50484d94ddbabbb28
--- /dev/null
+++ b/tests/statics/Vortex/fcm/response_missing_results.json
@@ -0,0 +1,6 @@
+{
+    "multicast_id": 108,
+    "success": 1,
+    "failure": 0,
+    "canonical_ids": 0
+}
diff --git a/tests/statics/Vortex/fcm/response_multiple_error.json b/tests/statics/Vortex/fcm/response_multiple_error.json
new file mode 100644
index 0000000000000000000000000000000000000000..ed58ec6d47fa31b92f5ef6c229476c34dd409434
--- /dev/null
+++ b/tests/statics/Vortex/fcm/response_multiple_error.json
@@ -0,0 +1,47 @@
+{
+    "multicast_id": 108,
+    "success": 0,
+    "failure": 13,
+    "canonical_ids": 0,
+    "results": [
+        {
+            "error": "MissingRegistration"
+        },
+        {
+            "error": "InvalidRegistration"
+        },
+        {
+            "error": "NotRegistered"
+        },
+        {
+            "error": "InvalidPackageName"
+        },
+        {
+            "error": "MismatchSenderId"
+        },
+        {
+            "error": "MessageTooBig"
+        },
+        {
+            "error": "InvalidDataKey"
+        },
+        {
+            "error": "InvalidTtl"
+        },
+        {
+            "error": "Unavailable"
+        },
+        {
+            "error": "InternalServerError"
+        },
+        {
+            "error": "DeviceMessageRateExceeded"
+        },
+        {
+            "error": "TopicsMessageRateExceeded"
+        },
+        {
+            "error": "unknown-stuff"
+        }
+    ]
+}
diff --git a/tests/statics/Vortex/fcm/response_multiple_mixed.json b/tests/statics/Vortex/fcm/response_multiple_mixed.json
new file mode 100644
index 0000000000000000000000000000000000000000..723bbd1a8b476fb2755e17b5348f5375be5afc4a
--- /dev/null
+++ b/tests/statics/Vortex/fcm/response_multiple_mixed.json
@@ -0,0 +1,23 @@
+{
+    "multicast_id": 108,
+    "success": 3,
+    "failure": 2,
+    "canonical_ids": 0,
+    "results": [
+        {
+            "error": "InvalidRegistration"
+        },
+        {
+            "message_id": "1:08"
+        },
+        {
+            "error": "InvalidRegistration"
+        },
+        {
+            "message_id": "1:08"
+        },
+        {
+            "message_id": "1:09"
+        }
+    ]
+}
diff --git a/tests/statics/Vortex/fcm/response_multiple_success.json b/tests/statics/Vortex/fcm/response_multiple_success.json
new file mode 100644
index 0000000000000000000000000000000000000000..25537f90886e9d3a9c68f630d03be147c5c56671
--- /dev/null
+++ b/tests/statics/Vortex/fcm/response_multiple_success.json
@@ -0,0 +1,17 @@
+{
+    "multicast_id": 108,
+    "success": 3,
+    "failure": 0,
+    "canonical_ids": 0,
+    "results": [
+        {
+            "message_id": "1:08"
+        },
+        {
+            "message_id": "1:08"
+        },
+        {
+            "message_id": "1:09"
+        }
+    ]
+}
diff --git a/tests/statics/Vortex/fcm/response_single_error.json b/tests/statics/Vortex/fcm/response_single_error.json
new file mode 100644
index 0000000000000000000000000000000000000000..f6a5c93367140fba4033aafc428ebfc853dbf1b2
--- /dev/null
+++ b/tests/statics/Vortex/fcm/response_single_error.json
@@ -0,0 +1,11 @@
+{
+    "multicast_id": 108,
+    "success": 0,
+    "failure": 1,
+    "canonical_ids": 0,
+    "results": [
+        {
+            "error": "InvalidRegistration"
+        }
+    ]
+}
diff --git a/tests/statics/Vortex/fcm/response_single_success.json b/tests/statics/Vortex/fcm/response_single_success.json
new file mode 100644
index 0000000000000000000000000000000000000000..48219d0ec3e9ba26febaa2fda05e0c296dcd42b7
--- /dev/null
+++ b/tests/statics/Vortex/fcm/response_single_success.json
@@ -0,0 +1,11 @@
+{
+    "multicast_id": 108,
+    "success": 1,
+    "failure": 0,
+    "canonical_ids": 0,
+    "results": [
+        {
+            "message_id": "1:08"
+        }
+    ]
+}
diff --git a/tests/statics/Vortex/fcm/time_to_live.json b/tests/statics/Vortex/fcm/time_to_live.json
new file mode 100644
index 0000000000000000000000000000000000000000..21ec6c11e250f97be8ff31d4cbfd67f3efb4edd2
--- /dev/null
+++ b/tests/statics/Vortex/fcm/time_to_live.json
@@ -0,0 +1 @@
+{"time_to_live":10}
\ No newline at end of file
