Add Jobs support

31 files changed, 3118 insertions, 61 deletions

diff --git a/README.md b/README.md
index 8b762d4..acacd1a 100644
--- a/README.md
+++ b/README.md
@@ -16,6 +16,9 @@ The Device SDK provides functionality to create and maintain a mutually authenti
 ### Thing Shadow
 The Device SDK implements the specific protocol for Thing Shadows to retrieve, update and delete Thing Shadows adhering to the protocol that is implemented to ensure correct versioning and support for client tokens. It abstracts the necessary MQTT topic subscriptions by automatically subscribing to and unsubscribing from the reserved topics as needed for each API call. Inbound state change requests are automatically signalled via a configurable callback.
 
+### Jobs
+The Device SDK implements features to facilitate use of the AWS Jobs service. The Jobs service can be used for device management tasks such as updating program files, rotating device certificates, or running other maintenance tasks such are restoring device settings or restarting devices.
+
 ## Design Goals of this SDK
 The embedded C SDK was specifically designed for resource constrained devices (running on micro-controllers and RTOS).
 
diff --git a/include/aws_iot_error.h b/include/aws_iot_error.h
index 03f297b..f0ccc39 100644
--- a/include/aws_iot_error.h
+++ b/include/aws_iot_error.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License").
  * You may not use this file except in compliance with the License.
@@ -151,6 +151,12 @@ typedef enum {
                         MUTEX_UNLOCK_ERROR = -48,
         /** Mutex destroy failed */
                         MUTEX_DESTROY_ERROR = -49,
+        /** Input argument exceeded the allowed maximum size */
+                        MAX_SIZE_ERROR = -50,
+        /** Some limit has been exceeded, e.g. the maximum number of subscriptions has been reached */
+                        LIMIT_EXCEEDED_ERROR = -51,
+        /** Invalid input topic type */
+                        INVALID_TOPIC_TYPE_ERROR = -52
 } IoT_Error_t;
 
 #ifdef __cplusplus
diff --git a/include/aws_iot_jobs_interface.h b/include/aws_iot_jobs_interface.h
new file mode 100644
index 0000000..4f033d9
--- /dev/null
+++ b/include/aws_iot_jobs_interface.h
@@ -0,0 +1,267 @@
+/*
+ * Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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.
+ */
+
+/**
+ * @file aws_iot_jobs_interface.h
+ * @brief An interface for interacting with the AWS IoT Jobs system.
+ *
+ * This file defines utility functions for interacting with the AWS IoT jobs
+ * APIs over MQTT. It provides functions for managing subscriptions to job
+ * related topics and for sending queries and updates requests for jobs.
+ * Callers are responsible for managing the subscriptions and associating
+ * responses with the queries and update messages.
+ */
+#ifndef AWS_IOT_JOBS_INTERFACE_H_
+#define AWS_IOT_JOBS_INTERFACE_H_
+
+#ifdef DISABLE_IOT_JOBS
+#error "Jobs API is disabled"
+#endif
+
+/**
+ * @file aws_iot_jobs_interface.h
+ * @brief Functions for interacting with the AWS IoT Jobs system.
+ */
+#include "aws_iot_mqtt_client_interface.h"
+#include "aws_iot_jobs_topics.h"
+#include "aws_iot_jobs_types.h"
+#include "aws_iot_error.h"
+#include "aws_iot_json_utils.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Subscribe to jobs messages for the given thing and/or jobs.
+ *
+ * The function can be used to subscribe to all job related messages. To subscribe
+ * to messages not related to a job the jobId passed should be null. The jobId
+ * can also be "+" to subscribe to messages related to any job, or "$next" to
+ * indicate the next pending job.
+ *
+ * See also #aws_iot_jobs_subscribe_to_all_job_messages to subscribe to all possible
+ * messages in one operation.
+ *
+ * \note Subscribing with the same thing, job and topic type more than
+ *   once is undefined.
+ *
+ * \param pClient the client to use
+ * \param qos the qos to use
+ * \param thingName the name of the thing to subscribe to
+ * \param jobId the job id to subscribe to. To subscribe to messages not related to 
+ *   a job the jobId passed should be null. The jobId can also be "+" to subscribe to 
+ *   messages related to any job, or "$next" to indicate the next pending job.
+ * \param topicType the topic type to subscribe to
+ * \param replyType the reply topic type to subscribe to
+ * \param pApplicationHandler the callback handler
+ * \param pApplicationHandlerData the callback context data. This must remain valid at least until
+ *   aws_iot_jobs_unsubscribe_from_job_messages is called.
+ * \param topicBuffer. A buffer to use to hold the topic name for the subscription. This buffer
+ *   must remain valid at least until aws_iot_jobs_unsubscribe_from_job_messages is called.
+ * \param topicBufferSize the size of the topic buffer. The function will fail
+ *   with LIMIT_EXCEEDED_ERROR if this is too small.
+ * \return the result of subscribing to the topic (see aws_iot_mqtt_subscribe)
+ */
+IoT_Error_t aws_iot_jobs_subscribe_to_job_messages(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                const char *jobId,
+                AwsIotJobExecutionTopicType topicType,
+                AwsIotJobExecutionTopicReplyType replyType,
+                pApplicationHandler_t pApplicationHandler,
+                void *pApplicationHandlerData,
+                char *topicBuffer,
+                uint16_t topicBufferSize);
+
+/**
+ * @brief Subscribe to all job messages.
+ *
+ * Subscribe to all job messages for the given thing.
+ *
+ * \note Subscribing with the same thing more than once is undefined.
+ *
+ * \param pClient the client to use
+ * \param qos the qos to use
+ * \param thingName the name of the thing to subscribe to
+ * \param pApplicationHandler the callback handler
+ * \param pApplicationHandlerData the callback context data. This must remain valid at least until
+ *   aws_iot_jobs_unsubscribe_from_job_messages is called.
+ * \param topicBuffer. A buffer to use to hold the topic name for the subscription. This buffer
+ *   must remain valid at least until aws_iot_jobs_unsubscribe_from_job_messages is called.
+ * \param topicBufferSize the size of the topic buffer. The function will fail
+ *   with LIMIT_EXCEEDED_ERROR if this is too small.
+ * \return the result of subscribing to the topic (see aws_iot_mqtt_subscribe)
+ */
+IoT_Error_t aws_iot_jobs_subscribe_to_all_job_messages(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                pApplicationHandler_t pApplicationHandler,
+                void *pApplicationHandlerData,
+                char *topicBuffer,
+                uint16_t topicBufferSize);
+
+/**
+ * @brief Unsubscribe from a job subscription
+ *
+ * Remove the subscription created using #aws_iot_jobs_subscribe_to_job_messages or
+ *   #aws_iot_jobs_subscribe_to_all_job_messages.
+ *
+ * \param pClient the client to use
+ * \param topicBuffer the topic buffer passed to #aws_iot_jobs_subscribe_to_job_messages or 
+ *   #aws_iot_jobs_subscribe_to_all_job_messages when the subscription was created.
+ * \return #SUCCESS or the first error encountered.
+ */
+IoT_Error_t aws_iot_jobs_unsubscribe_from_job_messages(
+                AWS_IoT_Client *pClient,
+                char *topicBuffer);
+
+/**
+ * @brief Send a query to one of the job query APIs.
+ *
+ * Send a query to one of the job query APIs. If jobId is null this
+ * requests a list of pending jobs for the thing. If jobId is
+ * not null then it sends a query for the details of that job.
+ * If jobId is $next then it sends a query for the details for
+ * the next pending job.
+ *
+ * \param pClient the client to use
+ * \param qos the qos to use
+ * \param thingName the thing name to query for
+ * \param jobId the id of the job to query for. If null a list
+ *   of all pending jobs for the thing is requested.
+ * \param clientToken the client token to use for the query.
+ *   If null no clientToken is sent resulting in an empty message.
+ * \param topicBuffer the topic buffer to use. This may be discarded
+ *   as soon as this function returns
+ * \param topicBufferSize the size of topicBuffer
+ * \param messageBuffer the message buffer to use. May be NULL
+ *   if clientToken is NULL
+ * \param messageBufferSize the size of messageBuffer
+ * \param topicType the topic type to publish query to
+ * \return LIMIT_EXCEEDED_ERROR if the topic buffer or
+ *   message buffer is too small, NULL_VALUE_ERROR if the any of
+ *   the required inputs are NULL, otherwise the result
+ *   of the mqtt publish
+ */
+IoT_Error_t aws_iot_jobs_send_query(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                const char *jobId,
+                const char *clientToken,
+                char *topicBuffer,
+                uint16_t topicBufferSize,
+                char *messageBuffer,
+                size_t messageBufferSize,
+                AwsIotJobExecutionTopicType topicType);
+
+/**
+ * @brief Send a start next command to the job start-next API.
+ *
+ * Send a start next command to the job start-next API.
+ *
+ * \param pClient the client to use
+ * \param qos the qos to use
+ * \param thingName the thing name to query for
+ * \param startNextRequest the start-next request to send
+ * \param topicBuffer the topic buffer to use. This may be discarded
+ *   as soon as this function returns
+ * \param topicBufferSize the size of topicBuffer
+ * \param messageBuffer the message buffer to use. May be NULL
+ *   if clientToken is NULL
+ * \param messageBufferSize the size of messageBuffer
+ * \return LIMIT_EXCEEDED_ERROR if the topic buffer or
+ *   message buffer is too small, NULL_VALUE_ERROR if the any of
+ *   the required inputs are NULL, otherwise the result
+ *   of the mqtt publish
+ */
+IoT_Error_t aws_iot_jobs_start_next(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                const AwsIotStartNextPendingJobExecutionRequest *startNextRequest,
+                char *topicBuffer,
+                uint16_t topicBufferSize,
+                char *messageBuffer,
+                size_t messageBufferSize);
+
+/**
+ * @brief Send a describe job query to the job query API.
+ *
+ * Send a describe job query to the job query API. If jobId is null this
+ * requests a list of pending jobs for the thing. If jobId is
+ * not null then it sends a query for the details of that job.
+ *
+ * \param pClient the client to use
+ * \param qos the qos to use
+ * \param thingName the thing name to query for
+ * \param jobId the id of the job to query for. If null a list
+ *   of all pending jobs for the thing is requested.
+ * \param describeRequest the describe request to send
+ * \param topicBuffer the topic buffer to use. This may be discarded
+ *   as soon as this function returns
+ * \param topicBufferSize the size of topicBuffer
+ * \param messageBuffer the message buffer to use. May be NULL
+ *   if clientToken is NULL
+ * \param messageBufferSize the size of messageBuffer
+ * \return LIMIT_EXCEEDED_ERROR if the topic buffer or
+ *   message buffer is too small, NULL_VALUE_ERROR if the any of
+ *   the required inputs are NULL, otherwise the result
+ *   of the mqtt publish
+ */
+IoT_Error_t aws_iot_jobs_describe(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                const char *jobId,
+                const AwsIotDescribeJobExecutionRequest *describeRequest,
+                char *topicBuffer,
+                uint16_t topicBufferSize,
+                char *messageBuffer,
+                size_t messageBufferSize);
+
+/**
+ * @brief Send an update about a job execution.
+ *
+ * Send an update about a job execution.
+ *
+ * \param pClient the client to use
+ * \param qos the qos to use
+ * \param thingName the thing name to send the update for
+ * \param jobId the id of the job to send the update for
+ * \param updateRequest the update request to send
+ * \param topicBuffer the topic buffer to use. This may be discarded
+ *   as soon as this function returns
+ * \param topicBufferSize the size of topicBuffer
+ * \param messageBuffer the message buffer to use.
+ * \param messageBufferSize the size of messageBuffer
+ * \return LIMIT_EXCEEDED_ERROR if the topic buffer or
+ *   message buffer is too small, NULL_VALUE_ERROR if the any of
+ *   the required inputs are NULL, otherwise the result
+ *   of the mqtt publish
+ */
+IoT_Error_t aws_iot_jobs_send_update(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                const char *jobId,
+                const AwsIotJobExecutionUpdateRequest *updateRequest,
+                char *topicBuffer,
+                uint16_t topicBufferSize,
+                char *messageBuffer,
+                size_t messageBufferSize);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AWS_IOT_JOBS_INTERFACE_H_ */
diff --git a/include/aws_iot_jobs_json.h b/include/aws_iot_jobs_json.h
new file mode 100644
index 0000000..55e4514
--- /dev/null
+++ b/include/aws_iot_jobs_json.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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.
+ */
+
+/**
+ * @file aws_iot_jobs_json.h
+ * @brief Functions for mapping between json and the AWS Iot Job data structures.
+ */
+
+#ifdef DISABLE_IOT_JOBS
+#error "Jobs API is disabled"
+#endif
+
+#ifndef AWS_IOT_JOBS_JSON_H_
+#define AWS_IOT_JOBS_JSON_H_
+
+#include <stdbool.h>
+#include "jsmn.h"
+#include "aws_iot_jobs_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Serialize a job execution update request into a json string.
+ *
+ * \param requestBuffer buffer to contain the serialized request. If null
+ *   this function will return the size of the buffer required
+ * \param bufferSize the size of the buffer. If this is smaller than the required
+ *   length the string will be truncated to fit.
+ * \request the request to serialize.
+ * \return The size of the json string to store the serialized request or -1
+ *   if the request is invalid. Note that the return value should be checked against
+ *   the size of the buffer and if its larger handle the fact that the string has
+ *   been truncated.
+ */
+int aws_iot_jobs_json_serialize_update_job_execution_request(
+                char *requestBuffer, size_t bufferSize,
+                const AwsIotJobExecutionUpdateRequest *request);
+
+/**
+ * Serialize a job API request that contains only a client token.
+ *
+ * \param requestBuffer buffer to contain the serialized request. If null
+ *   this function will return the size of the buffer required
+ * \param bufferSize the size of the buffer. If this is smaller than the required
+ *   length the string will be truncated to fit.
+ * \param clientToken the client token to use for the request.
+ * \return The size of the json string to store the serialized request or -1
+ *   if the request is invalid. Note that the return value should be checked against
+ *   the size of the buffer and if its larger handle the fact that the string has
+ *   been truncated.
+ */
+int aws_iot_jobs_json_serialize_client_token_only_request(
+                char *requestBuffer, size_t bufferSize,
+                const char *clientToken);
+
+/**
+ * Serialize describe job execution request into json string.
+ *
+ * \param requestBuffer buffer to contain the serialized request. If null
+ *   this function will return the size of the buffer required
+ * \param bufferSize the size of the buffer. If this is smaller than the required
+ *   length the string will be truncated to fit.
+ * \param request the request to serialize.
+ * \return The size of the json string to store the serialized request or -1
+ *   if the request is invalid. Note that the return value should be checked against
+ *   the size of the buffer and if its larger handle the fact that the string has
+ *   been truncated.
+ */
+int aws_iot_jobs_json_serialize_describe_job_execution_request(
+                char *requestBuffer, size_t bufferSize,
+                const AwsIotDescribeJobExecutionRequest *request);
+
+/**
+ * Serialize start next job execution request into json string.
+ *
+ * \param requestBuffer buffer to contain the serialized request. If null
+ *   this function will return the size of the buffer required
+ * \param bufferSize the size of the buffer. If this is smaller than the required
+ *   length the string will be truncated to fit.
+ * \param request the start-next request to serialize.
+ * \return The size of the json string to store the serialized request or -1
+ *   if the request is invalid. Note that the return value should be checked against
+ *   the size of the buffer and if its larger handle the fact that the string has
+ *   been truncated.
+ */
+int aws_iot_jobs_json_serialize_start_next_job_execution_request(
+                char *requestBuffer, size_t bufferSize,
+                const AwsIotStartNextPendingJobExecutionRequest *request);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AWS_IOT_JOBS_JSON_H_ */
diff --git a/include/aws_iot_jobs_topics.h b/include/aws_iot_jobs_topics.h
new file mode 100644
index 0000000..3e29187
--- /dev/null
+++ b/include/aws_iot_jobs_topics.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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.
+ */
+
+/**
+ * @file aws_iot_job_topics.h
+ * @brief Functions for parsing and creating MQTT topics used by the AWS IoT Jobs system.
+ */
+
+#ifdef DISABLE_IOT_JOBS
+#error "Jobs API is disabled"
+#endif
+
+#ifndef AWS_IOT_JOBS_TOPICS_H_
+#define AWS_IOT_JOBS_TOPICS_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define JOB_ID_NEXT     "$next"
+#define JOB_ID_WILDCARD "+"
+
+/**
+ * The type of job topic.
+ */
+typedef enum {
+        JOB_UNRECOGNIZED_TOPIC = 0,
+        JOB_GET_PENDING_TOPIC,
+        JOB_START_NEXT_TOPIC,
+        JOB_DESCRIBE_TOPIC,
+        JOB_UPDATE_TOPIC,
+        JOB_NOTIFY_TOPIC,
+        JOB_NOTIFY_NEXT_TOPIC,
+        JOB_WILDCARD_TOPIC
+} AwsIotJobExecutionTopicType;
+
+/**
+ * The type of reply topic, or #JOB_REQUEST_TYPE for
+ * topics that are not replies.
+ */
+typedef enum {
+        JOB_UNRECOGNIZED_TOPIC_TYPE = 0,
+        JOB_REQUEST_TYPE,
+        JOB_ACCEPTED_REPLY_TYPE,
+        JOB_REJECTED_REPLY_TYPE,
+        JOB_WILDCARD_REPLY_TYPE
+} AwsIotJobExecutionTopicReplyType;
+
+/**
+ * @brief Get the topic matching the provided details and put into the provided buffer.
+ *
+ * If the buffer is not large enough to store the full topic the topic will be truncated
+ * to fit, with the last character always being a null terminator.
+ *
+ * \param buffer the buffer to put the results into
+ * \param bufferSize the size of the buffer
+ * \param topicType the type of the topic
+ * \param replyType the reply type of the topic
+ * \param thingName the name of the thing in the topic
+ * \param jobId the name of the job id in the topic
+ * \return the number of characters in the topic excluding the null terminator. A return
+ *   value of bufferSize or more means that the topic string was truncated.
+ */
+int aws_iot_jobs_get_api_topic(char *buffer, size_t bufferSize,
+                AwsIotJobExecutionTopicType topicType, AwsIotJobExecutionTopicReplyType replyType,
+                const char* thingName, const char* jobId);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AWS_IOT_JOBS_TOPICS_H_ */
diff --git a/include/aws_iot_jobs_types.h b/include/aws_iot_jobs_types.h
new file mode 100644
index 0000000..22ba62f
--- /dev/null
+++ b/include/aws_iot_jobs_types.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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.
+ */
+
+/**
+ * @file aws_iot_jobs_types.h
+ * @brief Structures defining the interface with the AWS IoT Jobs system
+ *
+ * This file defines the structures returned by and sent to the AWS IoT Jobs system.
+ *
+ */
+
+#ifdef DISABLE_IOT_JOBS
+#error "Jobs API is disabled"
+#endif
+
+#ifndef AWS_IOT_JOBS_TYPES_H_
+#define AWS_IOT_JOBS_TYPES_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "jsmn.h"
+#include "timer_interface.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+        JOB_EXECUTION_STATUS_NOT_SET = 0,
+        JOB_EXECUTION_QUEUED,
+        JOB_EXECUTION_IN_PROGRESS,
+        JOB_EXECUTION_FAILED,
+        JOB_EXECUTION_SUCCEEDED,
+        JOB_EXECUTION_CANCELED,
+        JOB_EXECUTION_REJECTED,
+        /***
+         * Used for any status not in the supported list of statuses
+         */
+        JOB_EXECUTION_UNKNOWN_STATUS = 99
+} JobExecutionStatus;
+
+extern const char *JOB_EXECUTION_QUEUED_STR;
+extern const char *JOB_EXECUTION_IN_PROGRESS_STR;
+extern const char *JOB_EXECUTION_FAILED_STR;
+extern const char *JOB_EXECUTION_SUCCESS_STR;
+extern const char *JOB_EXECUTION_CANCELED_STR;
+extern const char *JOB_EXECUTION_REJECTED_STR;
+
+/**
+ * Convert a string to its matching status.
+ *
+ * \return the matching status, or JOB_EXECUTION_UNKNOWN_STATUS if the string was not recognized.
+ */
+JobExecutionStatus aws_iot_jobs_map_string_to_job_status(const char *str);
+
+/**
+ * Convert a status to its string.
+ *
+ * \return a string representing the status, or null if the status is not recognized.
+ */
+const char *aws_iot_jobs_map_status_to_string(JobExecutionStatus status);
+
+/**
+ * A request to update the status of a job execution.
+ */
+typedef struct {
+        int64_t expectedVersion;        // set to 0 to ignore
+        int64_t executionNumber;        // set to 0 to ignore
+        JobExecutionStatus status;
+        const char *statusDetails;
+        bool includeJobExecutionState;
+        bool includeJobDocument;
+        const char *clientToken;
+} AwsIotJobExecutionUpdateRequest;
+
+/**
+ * A request to get the status of a job execution.
+ */
+typedef struct {
+        int64_t executionNumber;        // set to 0 to ignore
+        bool includeJobDocument;
+        const char *clientToken;
+} AwsIotDescribeJobExecutionRequest;
+
+/**
+ * A request to get and start the next pending (not in a terminal state) job execution for a Thing.
+ */
+typedef struct {
+        const char *statusDetails;
+        const char *clientToken;
+} AwsIotStartNextPendingJobExecutionRequest;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AWS_IOT_JOBS_TYPES_H_ */
diff --git a/include/aws_iot_json_utils.h b/include/aws_iot_json_utils.h
index ceb02b3..2c040cf 100644
--- a/include/aws_iot_json_utils.h
+++ b/include/aws_iot_json_utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License").
  * You may not use this file except in compliance with the License.
@@ -190,6 +190,20 @@ IoT_Error_t parseBooleanValue(bool *b, const char *jsonString, jsmntok_t *token)
  */
 IoT_Error_t parseStringValue(char *buf, const char *jsonString, jsmntok_t *token);
 
+/**
+ * @brief          Find the JSON node associated with the given key in the given object.
+ *
+ * Given a JSON node parse the string value from the value.
+ *
+ * @param key                   json key
+ * @param token                 json token - pointer to JSON node
+ * @param jsonString    json string
+ *
+ * @return                              pointer to found property value
+ * @return                              NULL - not found
+ */
+jsmntok_t *findToken(const char *key, const char *jsonString, jsmntok_t *token);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/samples/linux/jobs_sample/Makefile b/samples/linux/jobs_sample/Makefile
new file mode 100644
index 0000000..5fc68e6
--- /dev/null
+++ b/samples/linux/jobs_sample/Makefile
@@ -0,0 +1,70 @@
+#This target is to ensure accidental execution of Makefile as a bash script will not execute commands like rm in unexpected directories and exit gracefully.
+.prevent_execution:
+        exit 0
+
+CC = gcc
+
+#remove @ for no make command prints
+DEBUG = @
+
+APP_DIR = .
+APP_INCLUDE_DIRS += -I $(APP_DIR)
+APP_NAME = jobs_sample
+APP_SRC_FILES = $(APP_NAME).c
+
+#IoT client directory
+IOT_CLIENT_DIR = ../../..
+
+PLATFORM_DIR = $(IOT_CLIENT_DIR)/platform/linux/mbedtls
+PLATFORM_COMMON_DIR = $(IOT_CLIENT_DIR)/platform/linux/common
+
+IOT_INCLUDE_DIRS += -I $(IOT_CLIENT_DIR)/include
+IOT_INCLUDE_DIRS += -I $(IOT_CLIENT_DIR)/sdk_config
+IOT_INCLUDE_DIRS += -I $(IOT_CLIENT_DIR)/external_libs/jsmn
+IOT_INCLUDE_DIRS += -I $(PLATFORM_COMMON_DIR)
+IOT_INCLUDE_DIRS += -I $(PLATFORM_DIR)
+
+IOT_SRC_FILES += $(shell find $(IOT_CLIENT_DIR)/src/ -name '*.c')
+IOT_SRC_FILES += $(shell find $(IOT_CLIENT_DIR)/external_libs/jsmn -name '*.c')
+IOT_SRC_FILES += $(shell find $(PLATFORM_DIR)/ -name '*.c')
+IOT_SRC_FILES += $(shell find $(PLATFORM_COMMON_DIR)/ -name '*.c')
+
+#TLS - mbedtls
+MBEDTLS_DIR = $(IOT_CLIENT_DIR)/external_libs/mbedTLS
+TLS_LIB_DIR = $(MBEDTLS_DIR)/library
+TLS_INCLUDE_DIR = -I $(MBEDTLS_DIR)/include
+EXTERNAL_LIBS += -L$(TLS_LIB_DIR)
+LD_FLAG += -Wl,-rpath,$(TLS_LIB_DIR)
+LD_FLAG += -ldl $(TLS_LIB_DIR)/libmbedtls.a $(TLS_LIB_DIR)/libmbedcrypto.a $(TLS_LIB_DIR)/libmbedx509.a -lpthread
+
+#Aggregate all include and src directories
+INCLUDE_ALL_DIRS += $(IOT_INCLUDE_DIRS)
+INCLUDE_ALL_DIRS += $(TLS_INCLUDE_DIR)
+INCLUDE_ALL_DIRS += $(APP_INCLUDE_DIRS)
+
+SRC_FILES += $(APP_SRC_FILES)
+SRC_FILES += $(IOT_SRC_FILES)
+
+# Logging level control
+LOG_FLAGS += -DENABLE_IOT_DEBUG
+LOG_FLAGS += -DENABLE_IOT_INFO
+LOG_FLAGS += -DENABLE_IOT_WARN
+LOG_FLAGS += -DENABLE_IOT_ERROR
+
+COMPILER_FLAGS += $(LOG_FLAGS)
+#If the processor is big endian uncomment the compiler flag
+#COMPILER_FLAGS += -DREVERSED
+
+MBED_TLS_MAKE_CMD = $(MAKE) -C $(MBEDTLS_DIR)
+
+PRE_MAKE_CMD = $(MBED_TLS_MAKE_CMD)
+MAKE_CMD = $(CC) $(SRC_FILES) $(COMPILER_FLAGS) -o $(APP_NAME) $(LD_FLAG) $(EXTERNAL_LIBS) $(INCLUDE_ALL_DIRS)
+
+all:
+        $(PRE_MAKE_CMD)
+        $(DEBUG)$(MAKE_CMD)
+        $(POST_MAKE_CMD)
+
+clean:
+        rm -f $(APP_DIR)/$(APP_NAME)
+        $(MBED_TLS_MAKE_CMD) clean
diff --git a/samples/linux/jobs_sample/aws_iot_config.h b/samples/linux/jobs_sample/aws_iot_config.h
new file mode 100644
index 0000000..8bd8a7d
--- /dev/null
+++ b/samples/linux/jobs_sample/aws_iot_config.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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.
+ */
+
+/**
+ * @file aws_iot_config.h
+ * @brief AWS IoT specific configuration file
+ */
+
+#ifndef SRC_JOBS_IOT_JOB_CONFIG_H_
+#define SRC_JOBS_IOT_JOB_CONFIG_H_
+
+// Get from console
+// =================================================
+#define AWS_IOT_MQTT_HOST              "" ///< Customer specific MQTT HOST. The same will be used for Thing Shadow
+#define AWS_IOT_MQTT_PORT              8883 ///< default port for MQTT/S
+#define AWS_IOT_MQTT_CLIENT_ID         "c-sdk-client-id" ///< MQTT client ID should be unique for every device
+#define AWS_IOT_MY_THING_NAME          "AWS-IoT-C-SDK" ///< Thing Name of the Shadow this device is associated with
+#define AWS_IOT_ROOT_CA_FILENAME       "rootCA.crt" ///< Root CA file name
+#define AWS_IOT_CERTIFICATE_FILENAME   "cert.pem" ///< device signed certificate file name
+#define AWS_IOT_PRIVATE_KEY_FILENAME   "privkey.pem" ///< Device private key filename
+
+// MQTT PubSub
+#ifndef DISABLE_IOT_JOBS
+#define AWS_IOT_MQTT_RX_BUF_LEN 512 ///< Any message that comes into the device should be less than this buffer size. If a received message is bigger than this buffer size the message will be dropped.
+#else
+#define AWS_IOT_MQTT_RX_BUF_LEN 2048
+#endif
+#define AWS_IOT_MQTT_TX_BUF_LEN 512 ///< Any time a message is sent out through the MQTT layer. The message is copied into this buffer anytime a publish is done. This will also be used in the case of Thing Shadow
+#define AWS_IOT_MQTT_NUM_SUBSCRIBE_HANDLERS 5 ///< Maximum number of topic filters the MQTT client can handle at any given time. This should be increased appropriately when using Thing Shadow
+
+// Shadow and Job common configs
+#define MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES 80  ///< Maximum size of the Unique Client Id. For More info on the Client Id refer \ref response "Acknowledgments"
+#define MAX_SIZE_CLIENT_ID_WITH_SEQUENCE MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES + 10 ///< This is size of the extra sequence number that will be appended to the Unique client Id
+#define MAX_SIZE_CLIENT_TOKEN_CLIENT_SEQUENCE MAX_SIZE_CLIENT_ID_WITH_SEQUENCE + 20 ///< This is size of the the total clientToken key and value pair in the JSON
+#define MAX_SIZE_OF_THING_NAME 30 ///< The Thing Name should not be bigger than this value. Modify this if the Thing Name needs to be bigger
+
+// Thing Shadow specific configs
+#define SHADOW_MAX_SIZE_OF_RX_BUFFER 512 ///< Maximum size of the SHADOW buffer to store the received Shadow message
+#define MAX_ACKS_TO_COMEIN_AT_ANY_GIVEN_TIME 10 ///< At Any given time we will wait for this many responses. This will correlate to the rate at which the shadow actions are requested
+#define MAX_THINGNAME_HANDLED_AT_ANY_GIVEN_TIME 10 ///< We could perform shadow action on any thing Name and this is maximum Thing Names we can act on at any given time
+#define MAX_JSON_TOKEN_EXPECTED 120 ///< These are the max tokens that is expected to be in the Shadow JSON document. Include the metadata that gets published
+#define MAX_SHADOW_TOPIC_LENGTH_WITHOUT_THINGNAME 60 ///< All shadow actions have to be published or subscribed to a topic which is of the format $aws/things/{thingName}/shadow/update/accepted. This refers to the size of the topic without the Thing Name
+#define MAX_SHADOW_TOPIC_LENGTH_BYTES MAX_SHADOW_TOPIC_LENGTH_WITHOUT_THINGNAME + MAX_SIZE_OF_THING_NAME ///< This size includes the length of topic with Thing Name
+
+// Job specific configs
+#ifndef DISABLE_IOT_JOBS
+#define MAX_SIZE_OF_JOB_ID 64
+#define MAX_JOB_JSON_TOKEN_EXPECTED 120
+#define MAX_SIZE_OF_JOB_REQUEST AWS_IOT_MQTT_TX_BUF_LEN
+
+#define MAX_JOB_TOPIC_LENGTH_WITHOUT_JOB_ID_OR_THING_NAME 40
+#define MAX_JOB_TOPIC_LENGTH_BYTES MAX_JOB_TOPIC_LENGTH_WITHOUT_JOB_ID_OR_THING_NAME + MAX_SIZE_OF_THING_NAME + MAX_SIZE_OF_JOB_ID + 2
+#endif
+
+// Auto Reconnect specific config
+#define AWS_IOT_MQTT_MIN_RECONNECT_WAIT_INTERVAL 1000 ///< Minimum time before the First reconnect attempt is made as part of the exponential back-off algorithm
+#define AWS_IOT_MQTT_MAX_RECONNECT_WAIT_INTERVAL 128000 ///< Maximum time interval after which exponential back-off will stop attempting to reconnect.
+
+#define DISABLE_METRICS false ///< Disable the collection of metrics by setting this to true
+
+#endif /* SRC_JOBS_IOT_JOB_CONFIG_H_ */
diff --git a/samples/linux/jobs_sample/jobs_sample.c b/samples/linux/jobs_sample/jobs_sample.c
new file mode 100644
index 0000000..2f67551
--- /dev/null
+++ b/samples/linux/jobs_sample/jobs_sample.c
@@ -0,0 +1,368 @@
+/*
+ * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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.
+ */
+
+/**
+ *
+ * This example takes the parameters from the aws_iot_config.h file and establishes 
+ * a connection to the AWS IoT MQTT Platform. It performs several operations to 
+ * demonstrate the basic capabilities of the AWS IoT Jobs platform.
+ *
+ * If all the certs are correct, you should see the list of pending Job Executions 
+ * printed out by the iot_get_pending_callback_handler. If there are any existing pending 
+ * job executions each will be processed one at a time in the iot_next_job_callback_handler.
+ * After all of the pending jobs have been processed the program will wait for
+ * notifications for new pending jobs and process them one at a time as they come in.
+ * 
+ * In the main body you can see how each callback is registered for each corresponding
+ * Jobs topic.
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <limits.h>
+#include <string.h>
+
+#include "aws_iot_config.h"
+#include "aws_iot_json_utils.h"
+#include "aws_iot_log.h"
+#include "aws_iot_version.h"
+#include "aws_iot_mqtt_client_interface.h"
+#include "aws_iot_jobs_interface.h"
+
+/**
+ * @brief Default cert location
+ */
+char certDirectory[PATH_MAX + 1] = "../../../certs";
+
+/**
+ * @brief Default MQTT HOST URL is pulled from the aws_iot_config.h
+ */
+char HostAddress[255] = AWS_IOT_MQTT_HOST;
+
+/**
+ * @brief Default MQTT port is pulled from the aws_iot_config.h
+ */
+uint32_t port = AWS_IOT_MQTT_PORT;
+
+static jsmn_parser jsonParser;
+static jsmntok_t jsonTokenStruct[MAX_JSON_TOKEN_EXPECTED];
+static int32_t tokenCount;
+
+void iot_get_pending_callback_handler(AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen,
+                                                                        IoT_Publish_Message_Params *params, void *pData) {
+        IOT_UNUSED(pData);
+        IOT_UNUSED(pClient);
+        IOT_INFO("\nJOB_GET_PENDING_TOPIC callback");
+        IOT_INFO("topic: %.*s", topicNameLen, topicName);
+        IOT_INFO("payload: %.*s", (int) params->payloadLen, (char *)params->payload);
+
+        jsmn_init(&jsonParser);
+
+        tokenCount = jsmn_parse(&jsonParser, params->payload, (int) params->payloadLen, jsonTokenStruct, MAX_JSON_TOKEN_EXPECTED);
+
+        if(tokenCount < 0) {
+                IOT_WARN("Failed to parse JSON: %d", tokenCount);
+                return;
+        }
+
+        /* Assume the top-level element is an object */
+        if(tokenCount < 1 || jsonTokenStruct[0].type != JSMN_OBJECT) {
+                IOT_WARN("Top Level is not an object");
+                return;
+        }
+
+        jsmntok_t *jobs;
+
+        jobs = findToken("inProgressJobs", params->payload, jsonTokenStruct);
+
+        if (jobs) {
+                IOT_INFO("inProgressJobs: %.*s", jobs->end - jobs->start, (char *)params->payload + jobs->start);
+        }       
+
+        jobs = findToken("queuedJobs", params->payload, jsonTokenStruct);
+
+        if (jobs) {
+                IOT_INFO("queuedJobs: %.*s", jobs->end - jobs->start, (char *)params->payload + jobs->start);
+        }
+}
+
+void iot_next_job_callback_handler(AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen,
+                                                                        IoT_Publish_Message_Params *params, void *pData) {
+        char topicToPublishUpdate[MAX_JOB_TOPIC_LENGTH_BYTES];
+        char messageBuffer[200];
+
+        IOT_UNUSED(pData);
+        IOT_UNUSED(pClient);
+        IOT_INFO("\nJOB_NOTIFY_NEXT_TOPIC / JOB_DESCRIBE_TOPIC($next) callback");
+        IOT_INFO("topic: %.*s", topicNameLen, topicName);
+        IOT_INFO("payload: %.*s", (int) params->payloadLen, (char *)params->payload);
+
+        jsmn_init(&jsonParser);
+
+        tokenCount = jsmn_parse(&jsonParser, params->payload, (int) params->payloadLen, jsonTokenStruct, MAX_JSON_TOKEN_EXPECTED);
+
+        if(tokenCount < 0) {
+                IOT_WARN("Failed to parse JSON: %d", tokenCount);
+                return;
+        }
+
+        /* Assume the top-level element is an object */
+        if(tokenCount < 1 || jsonTokenStruct[0].type != JSMN_OBJECT) {
+                IOT_WARN("Top Level is not an object");
+                return;
+        }
+
+        jsmntok_t *tokExecution;
+
+        tokExecution = findToken("execution", params->payload, jsonTokenStruct);
+
+        if (tokExecution) {
+                IOT_INFO("execution: %.*s", tokExecution->end - tokExecution->start, (char *)params->payload + tokExecution->start);
+
+                jsmntok_t *tok;
+
+                tok = findToken("jobId", params->payload, tokExecution);
+
+                if (tok) {
+                        IoT_Error_t rc;
+                        char jobId[MAX_SIZE_OF_JOB_ID + 1];
+                        AwsIotJobExecutionUpdateRequest updateRequest;
+
+                        rc = parseStringValue(jobId, params->payload, tok);                     
+                        if(SUCCESS != rc) {
+                                IOT_ERROR("parseStringValue returned error : %d ", rc);
+                                return;
+                        }
+
+                        IOT_INFO("jobId: %s", jobId);
+
+                        tok = findToken("jobDocument", params->payload, tokExecution);
+
+                        /*
+                         * Do your job processing here.
+                         */
+
+                        if (tok) {
+                                IOT_INFO("jobDocument: %.*s", tok->end - tok->start, (char *)params->payload + tok->start);
+                                /* Alternatively if the job still has more steps the status can be set to JOB_EXECUTION_IN_PROGRESS instead */
+                                updateRequest.status = JOB_EXECUTION_SUCCEEDED;
+                                updateRequest.statusDetails = "{\"exampleDetail\":\"a value appropriate for your successful job\"}";
+                        } else {
+                                updateRequest.status = JOB_EXECUTION_FAILED;
+                                updateRequest.statusDetails = "{\"failureDetail\":\"Unable to process job document\"}";
+                        }
+
+                        updateRequest.expectedVersion = 0;
+                        updateRequest.executionNumber = 0;
+                        updateRequest.includeJobExecutionState = false;
+                        updateRequest.includeJobDocument = false;
+                        updateRequest.clientToken = NULL;
+
+                        rc = aws_iot_jobs_send_update(pClient, QOS0, AWS_IOT_MY_THING_NAME, jobId, &updateRequest, 
+                                        topicToPublishUpdate, sizeof(topicToPublishUpdate), messageBuffer, sizeof(messageBuffer));
+                }
+        } else {
+                IOT_INFO("execution property not found, nothing to do");                
+        }
+}
+
+void iot_update_accepted_callback_handler(AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen,
+                                                                        IoT_Publish_Message_Params *params, void *pData) {
+        IOT_UNUSED(pData);
+        IOT_UNUSED(pClient);
+        IOT_INFO("\nJOB_UPDATE_TOPIC / accepted callback");
+        IOT_INFO("topic: %.*s", topicNameLen, topicName);
+        IOT_INFO("payload: %.*s", (int) params->payloadLen, (char *)params->payload);
+}
+
+void iot_update_rejected_callback_handler(AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen,
+                                                                        IoT_Publish_Message_Params *params, void *pData) {
+        IOT_UNUSED(pData);
+        IOT_UNUSED(pClient);
+        IOT_INFO("\nJOB_UPDATE_TOPIC / rejected callback");
+        IOT_INFO("topic: %.*s", topicNameLen, topicName);
+        IOT_INFO("payload: %.*s", (int) params->payloadLen, (char *)params->payload);
+
+        /* Do error handling here for when the update was rejected */
+}
+
+void disconnectCallbackHandler(AWS_IoT_Client *pClient, void *data) {
+        IOT_WARN("MQTT Disconnect");
+        IoT_Error_t rc = FAILURE;
+
+        if(NULL == pClient) {
+                return;
+        }
+
+        IOT_UNUSED(data);
+
+        if(aws_iot_is_autoreconnect_enabled(pClient)) {
+                IOT_INFO("Auto Reconnect is enabled, Reconnecting attempt will start now");
+        } else {
+                IOT_WARN("Auto Reconnect not enabled. Starting manual reconnect...");
+                rc = aws_iot_mqtt_attempt_reconnect(pClient);
+                if(NETWORK_RECONNECTED == rc) {
+                        IOT_WARN("Manual Reconnect Successful");
+                } else {
+                        IOT_WARN("Manual Reconnect Failed - %d", rc);
+                }
+        }
+}
+
+int main(int argc, char **argv) {
+        char rootCA[PATH_MAX + 1];
+        char clientCRT[PATH_MAX + 1];
+        char clientKey[PATH_MAX + 1];
+        char CurrentWD[PATH_MAX + 1];
+        char cPayload[100];
+
+        int32_t i = 0;
+
+        IoT_Error_t rc = FAILURE;
+
+        AWS_IoT_Client client;
+        IoT_Client_Init_Params mqttInitParams = iotClientInitParamsDefault;
+        IoT_Client_Connect_Params connectParams = iotClientConnectParamsDefault;
+
+        IoT_Publish_Message_Params paramsQOS0;
+
+        getcwd(CurrentWD, sizeof(CurrentWD));
+        snprintf(rootCA, PATH_MAX + 1, "%s/%s/%s", CurrentWD, certDirectory, AWS_IOT_ROOT_CA_FILENAME);
+        snprintf(clientCRT, PATH_MAX + 1, "%s/%s/%s", CurrentWD, certDirectory, AWS_IOT_CERTIFICATE_FILENAME);
+        snprintf(clientKey, PATH_MAX + 1, "%s/%s/%s", CurrentWD, certDirectory, AWS_IOT_PRIVATE_KEY_FILENAME);
+
+        IOT_DEBUG("rootCA %s", rootCA);
+        IOT_DEBUG("clientCRT %s", clientCRT);
+        IOT_DEBUG("clientKey %s", clientKey);
+
+        mqttInitParams.enableAutoReconnect = false; // We enable this later below
+        mqttInitParams.pHostURL = HostAddress;
+        mqttInitParams.port = port;
+        mqttInitParams.pRootCALocation = rootCA;
+        mqttInitParams.pDeviceCertLocation = clientCRT;
+        mqttInitParams.pDevicePrivateKeyLocation = clientKey;
+        mqttInitParams.mqttCommandTimeout_ms = 20000;
+        mqttInitParams.tlsHandshakeTimeout_ms = 5000;
+        mqttInitParams.isSSLHostnameVerify = true;
+        mqttInitParams.disconnectHandler = disconnectCallbackHandler;
+        mqttInitParams.disconnectHandlerData = NULL;
+
+        rc = aws_iot_mqtt_init(&client, &mqttInitParams);
+        if(SUCCESS != rc) {
+                IOT_ERROR("aws_iot_mqtt_init returned error : %d ", rc);
+                return rc;
+        }
+
+        connectParams.keepAliveIntervalInSec = 600;
+        connectParams.isCleanSession = true;
+        connectParams.MQTTVersion = MQTT_3_1_1;
+        connectParams.pClientID = AWS_IOT_MQTT_CLIENT_ID;
+        connectParams.clientIDLen = (uint16_t) strlen(AWS_IOT_MQTT_CLIENT_ID);
+        connectParams.isWillMsgPresent = false;
+
+        IOT_INFO("Connecting...");
+        rc = aws_iot_mqtt_connect(&client, &connectParams);
+        if(SUCCESS != rc) {
+                IOT_ERROR("Error(%d) connecting to %s:%d", rc, mqttInitParams.pHostURL, mqttInitParams.port);
+                return rc;
+        }
+        /*
+         * Enable Auto Reconnect functionality. Minimum and Maximum time of Exponential backoff are set in aws_iot_config.h
+         *  #AWS_IOT_MQTT_MIN_RECONNECT_WAIT_INTERVAL
+         *  #AWS_IOT_MQTT_MAX_RECONNECT_WAIT_INTERVAL
+         */
+        rc = aws_iot_mqtt_autoreconnect_set_status(&client, true);
+        if(SUCCESS != rc) {
+                IOT_ERROR("Unable to set Auto Reconnect to true - %d", rc);
+                return rc;
+        }
+
+        char topicToSubscribeGetPending[MAX_JOB_TOPIC_LENGTH_BYTES];
+        char topicToSubscribeNotifyNext[MAX_JOB_TOPIC_LENGTH_BYTES];
+        char topicToSubscribeGetNext[MAX_JOB_TOPIC_LENGTH_BYTES];
+        char topicToSubscribeUpdateAccepted[MAX_JOB_TOPIC_LENGTH_BYTES];
+        char topicToSubscribeUpdateRejected[MAX_JOB_TOPIC_LENGTH_BYTES];
+
+        char topicToPublishGetPending[MAX_JOB_TOPIC_LENGTH_BYTES];
+        char topicToPublishGetNext[MAX_JOB_TOPIC_LENGTH_BYTES];
+
+        rc = aws_iot_jobs_subscribe_to_job_messages(
+                &client, QOS0, AWS_IOT_MY_THING_NAME, NULL, JOB_GET_PENDING_TOPIC, JOB_WILDCARD_REPLY_TYPE,
+                iot_get_pending_callback_handler, NULL, topicToSubscribeGetPending, sizeof(topicToSubscribeGetPending));
+
+        if(SUCCESS != rc) {
+                IOT_ERROR("Error subscribing JOB_GET_PENDING_TOPIC: %d ", rc);
+                return rc;
+        }
+
+        rc = aws_iot_jobs_subscribe_to_job_messages(
+                &client, QOS0, AWS_IOT_MY_THING_NAME, NULL, JOB_NOTIFY_NEXT_TOPIC, JOB_REQUEST_TYPE,
+                iot_next_job_callback_handler, NULL, topicToSubscribeNotifyNext, sizeof(topicToSubscribeNotifyNext));
+
+        if(SUCCESS != rc) {
+                IOT_ERROR("Error subscribing JOB_NOTIFY_NEXT_TOPIC: %d ", rc);
+                return rc;
+        }
+
+        rc = aws_iot_jobs_subscribe_to_job_messages(
+                &client, QOS0, AWS_IOT_MY_THING_NAME, JOB_ID_NEXT, JOB_DESCRIBE_TOPIC, JOB_WILDCARD_REPLY_TYPE,
+                iot_next_job_callback_handler, NULL, topicToSubscribeGetNext, sizeof(topicToSubscribeGetNext));
+
+        if(SUCCESS != rc) {
+                IOT_ERROR("Error subscribing JOB_DESCRIBE_TOPIC ($next): %d ", rc);
+                return rc;
+        }
+
+        rc = aws_iot_jobs_subscribe_to_job_messages(
+                &client, QOS0, AWS_IOT_MY_THING_NAME, JOB_ID_WILDCARD, JOB_UPDATE_TOPIC, JOB_ACCEPTED_REPLY_TYPE,
+                iot_update_accepted_callback_handler, NULL, topicToSubscribeUpdateAccepted, sizeof(topicToSubscribeUpdateAccepted));
+
+        if(SUCCESS != rc) {
+                IOT_ERROR("Error subscribing JOB_UPDATE_TOPIC/accepted: %d ", rc);
+                return rc;
+        }
+
+        rc = aws_iot_jobs_subscribe_to_job_messages(
+                &client, QOS0, AWS_IOT_MY_THING_NAME, JOB_ID_WILDCARD, JOB_UPDATE_TOPIC, JOB_REJECTED_REPLY_TYPE,
+                iot_update_rejected_callback_handler, NULL, topicToSubscribeUpdateRejected, sizeof(topicToSubscribeUpdateRejected));
+
+        if(SUCCESS != rc) {
+                IOT_ERROR("Error subscribing JOB_UPDATE_TOPIC/rejected: %d ", rc);
+                return rc;
+        }
+
+        paramsQOS0.qos = QOS0;
+        paramsQOS0.payload = (void *) cPayload;
+        paramsQOS0.isRetained = 0;
+        paramsQOS0.payloadLen = strlen(cPayload);
+
+        rc = aws_iot_jobs_send_query(&client, QOS0, AWS_IOT_MY_THING_NAME, NULL, NULL, topicToPublishGetPending, sizeof(topicToPublishGetPending), NULL, 0, JOB_GET_PENDING_TOPIC);
+
+        AwsIotDescribeJobExecutionRequest describeRequest;
+        describeRequest.executionNumber = 0;
+        describeRequest.includeJobDocument = true;
+        describeRequest.clientToken = NULL;
+
+        rc = aws_iot_jobs_describe(&client, QOS0, AWS_IOT_MY_THING_NAME, JOB_ID_NEXT, &describeRequest, topicToPublishGetNext, sizeof(topicToPublishGetNext), NULL, 0);
+
+        while(SUCCESS == rc) {
+                //Max time the yield function will wait for read messages
+                rc = aws_iot_mqtt_yield(&client, 50000);
+        }
+
+        return rc;
+}
diff --git a/src/aws_iot_jobs_interface.c b/src/aws_iot_jobs_interface.c
new file mode 100644
index 0000000..0452d67
--- /dev/null
+++ b/src/aws_iot_jobs_interface.c
@@ -0,0 +1,215 @@
+/*
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+* http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file 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.
+*/
+
+#include "aws_iot_jobs_interface.h"
+#include "aws_iot_log.h"
+#include "aws_iot_jobs_json.h"
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CHECK_GENERATE_STRING_RESULT(result, bufferSize) \
+        if (result < 0) { \
+                return FAILURE; \
+        } else if ((unsigned) result >= bufferSize) { \
+                return LIMIT_EXCEEDED_ERROR; \
+        }
+
+
+IoT_Error_t aws_iot_jobs_subscribe_to_job_messages(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                const char *jobId,
+                AwsIotJobExecutionTopicType topicType,
+                AwsIotJobExecutionTopicReplyType replyType,
+                pApplicationHandler_t pApplicationHandler,
+                void *pApplicationHandlerData,
+                char *topicBuffer,
+                uint16_t topicBufferSize)
+{
+        int requiredSize = aws_iot_jobs_get_api_topic(topicBuffer, topicBufferSize, topicType, replyType, thingName, jobId);
+        CHECK_GENERATE_STRING_RESULT(requiredSize, topicBufferSize);
+
+        return aws_iot_mqtt_subscribe(pClient, topicBuffer, (uint16_t)strlen(topicBuffer), qos, pApplicationHandler, pApplicationHandlerData);
+}
+
+IoT_Error_t aws_iot_jobs_subscribe_to_all_job_messages(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                pApplicationHandler_t pApplicationHandler,
+                void *pApplicationHandlerData,
+                char *topicBuffer,
+                uint16_t topicBufferSize)
+{
+        return aws_iot_jobs_subscribe_to_job_messages(pClient, qos, thingName, NULL, JOB_WILDCARD_TOPIC, JOB_WILDCARD_REPLY_TYPE,
+                        pApplicationHandler, pApplicationHandlerData, topicBuffer, topicBufferSize);
+}
+
+IoT_Error_t aws_iot_jobs_unsubscribe_from_job_messages(
+                AWS_IoT_Client *pClient,
+                char *topicBuffer) 
+{
+        return aws_iot_mqtt_unsubscribe(pClient, topicBuffer, (uint16_t)strlen(topicBuffer));
+}
+
+IoT_Error_t aws_iot_jobs_send_query(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                const char *jobId,
+                const char *clientToken,
+                char *topicBuffer,
+                uint16_t topicBufferSize,
+                char *messageBuffer,
+                size_t messageBufferSize,
+                AwsIotJobExecutionTopicType topicType)
+{
+        if (thingName == NULL || topicBuffer == NULL || (clientToken != NULL && messageBuffer == NULL)) {
+                return NULL_VALUE_ERROR;
+        }
+
+        int neededSize = aws_iot_jobs_get_api_topic(topicBuffer, topicBufferSize, topicType, JOB_REQUEST_TYPE, thingName, jobId);
+        CHECK_GENERATE_STRING_RESULT(neededSize, topicBufferSize);
+        uint16_t topicSize = (uint16_t) neededSize;
+
+        char emptyBuffer[1];
+        size_t messageLength;
+        if (clientToken == NULL) {
+                messageLength = 0;
+                messageBuffer = emptyBuffer;
+        } else {
+                int serializeResult = aws_iot_jobs_json_serialize_client_token_only_request(messageBuffer, messageBufferSize, clientToken);
+                CHECK_GENERATE_STRING_RESULT(serializeResult, messageBufferSize);
+                messageLength = (size_t)serializeResult;
+        }
+
+        IoT_Publish_Message_Params publishParams;
+        publishParams.qos = qos;
+        publishParams.isRetained = 0;
+        publishParams.isDup = 0;
+        publishParams.id = 0;
+        publishParams.payload = messageBuffer;
+        publishParams.payloadLen = messageLength;
+
+        return aws_iot_mqtt_publish(pClient, topicBuffer, topicSize, &publishParams);
+}
+
+IoT_Error_t aws_iot_jobs_start_next(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                const AwsIotStartNextPendingJobExecutionRequest *startNextRequest,
+                char *topicBuffer,
+                uint16_t topicBufferSize,
+                char *messageBuffer,
+                size_t messageBufferSize)
+{
+        if (thingName == NULL || topicBuffer == NULL || startNextRequest == NULL) {
+                return NULL_VALUE_ERROR;
+        }
+
+        int neededSize = aws_iot_jobs_get_api_topic(topicBuffer, topicBufferSize, JOB_START_NEXT_TOPIC, JOB_REQUEST_TYPE, thingName, NULL);
+        CHECK_GENERATE_STRING_RESULT(neededSize, topicBufferSize);
+        uint16_t topicSize = (uint16_t) neededSize;
+
+        int serializeResult = aws_iot_jobs_json_serialize_start_next_job_execution_request(messageBuffer, messageBufferSize, startNextRequest);
+        CHECK_GENERATE_STRING_RESULT(serializeResult, messageBufferSize);
+
+        IoT_Publish_Message_Params publishParams;
+        publishParams.qos = qos;
+        publishParams.isRetained = 0;
+        publishParams.isDup = 0;
+        publishParams.id = 0;
+        publishParams.payload = messageBuffer;
+        publishParams.payloadLen = (size_t) serializeResult;
+
+        return aws_iot_mqtt_publish(pClient, topicBuffer, topicSize, &publishParams);
+}
+
+IoT_Error_t aws_iot_jobs_describe(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                const char *jobId,
+                const AwsIotDescribeJobExecutionRequest *describeRequest,
+                char *topicBuffer,
+                uint16_t topicBufferSize,
+                char *messageBuffer,
+                size_t messageBufferSize)
+{
+        if (thingName == NULL || topicBuffer == NULL || describeRequest == NULL) {
+                return NULL_VALUE_ERROR;
+        }
+
+        int neededSize = aws_iot_jobs_get_api_topic(topicBuffer, topicBufferSize, JOB_DESCRIBE_TOPIC, JOB_REQUEST_TYPE, thingName, jobId);
+        CHECK_GENERATE_STRING_RESULT(neededSize, topicBufferSize);
+        uint16_t topicSize = (uint16_t) neededSize;
+
+        char emptyBuffer[1];
+        size_t messageLength;
+        if (messageBuffer == NULL) {
+                messageLength = 0;
+                messageBuffer = emptyBuffer;
+        } else {
+                int serializeResult = aws_iot_jobs_json_serialize_describe_job_execution_request(messageBuffer, messageBufferSize, describeRequest);
+                CHECK_GENERATE_STRING_RESULT(serializeResult, messageBufferSize);
+                messageLength = (size_t) serializeResult;
+        }
+
+        IoT_Publish_Message_Params publishParams;
+        publishParams.qos = qos;
+        publishParams.isRetained = 0;
+        publishParams.isDup = 0;
+        publishParams.id = 0;
+        publishParams.payload = messageBuffer;
+        publishParams.payloadLen = messageLength;
+
+        return aws_iot_mqtt_publish(pClient, topicBuffer, topicSize, &publishParams);
+}
+
+IoT_Error_t aws_iot_jobs_send_update(
+                AWS_IoT_Client *pClient, QoS qos,
+                const char *thingName,
+                const char *jobId,
+                const AwsIotJobExecutionUpdateRequest *updateRequest,
+                char *topicBuffer,
+                uint16_t topicBufferSize,
+                char *messageBuffer,
+                size_t messageBufferSize)
+{
+        if (thingName == NULL || topicBuffer == NULL || jobId == NULL || updateRequest == NULL) {
+                return NULL_VALUE_ERROR;
+        }
+
+        int neededSize = aws_iot_jobs_get_api_topic(topicBuffer, topicBufferSize, JOB_UPDATE_TOPIC, JOB_REQUEST_TYPE, thingName, jobId);
+        CHECK_GENERATE_STRING_RESULT(neededSize, topicBufferSize);
+        uint16_t topicSize = (uint16_t) neededSize;
+
+        int serializeResult = aws_iot_jobs_json_serialize_update_job_execution_request(messageBuffer, messageBufferSize, updateRequest);
+        CHECK_GENERATE_STRING_RESULT(serializeResult, messageBufferSize);
+
+        IoT_Publish_Message_Params publishParams;
+        publishParams.qos = qos;
+        publishParams.isRetained = 0;
+        publishParams.isDup = 0;
+        publishParams.id = 0;
+        publishParams.payload = messageBuffer;
+        publishParams.payloadLen = (size_t) serializeResult;
+
+        return aws_iot_mqtt_publish(pClient, topicBuffer, topicSize, &publishParams);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/aws_iot_jobs_json.c b/src/aws_iot_jobs_json.c
new file mode 100644
index 0000000..eaaed75
--- /dev/null
+++ b/src/aws_iot_jobs_json.c
@@ -0,0 +1,198 @@
+/*
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+* http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file 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.
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define __STDC_FORMAT_MACROS
+#include <string.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <inttypes.h>
+
+#include "jsmn.h"
+#include "aws_iot_jobs_json.h"
+
+struct _SerializeState {
+        int totalSize;
+        char *nextPtr;
+        size_t remaingSize;
+};
+
+static void _printToBuffer(struct _SerializeState *state, const char *fmt, ...) {
+        if (state->totalSize == -1) return;
+
+        va_list vl;
+        va_start(vl, fmt);
+        int len = vsnprintf(state->nextPtr, state->remaingSize, fmt, vl);
+        if (len < 0) {
+                state->totalSize = -1;
+        } else {
+                state->totalSize += len;
+                if (state->nextPtr != NULL) {
+                        if (state->remaingSize > (size_t) len) {
+                                state->remaingSize -= (size_t) len;
+                                state->nextPtr += len;
+                        } else {
+                                state->remaingSize = 0;
+                                state->nextPtr = NULL;
+                        }
+                }
+        }
+        va_end(vl);
+}
+
+static void _printKey(struct _SerializeState *state, bool first, const char *key) {
+        if (first) {
+                _printToBuffer(state, "{\"%s\":", key);
+        } else {
+                _printToBuffer(state, ",\"%s\":", key);
+        }
+}
+
+static void _printStringValue(struct _SerializeState *state, const char *value) {
+        if (value == NULL) {
+                _printToBuffer(state, "null");
+        } else {
+                _printToBuffer(state, "\"%s\"", value);
+        }
+}
+
+static void _printLongValue(struct _SerializeState *state, int64_t value) {
+        _printToBuffer(state, "%" PRId64, value);
+}
+
+static void _printBooleanValue(struct _SerializeState *state, bool value) {
+        if(value) {
+                _printToBuffer(state, "true");
+        } else {
+                _printToBuffer(state, "false");
+        }
+}
+
+int aws_iot_jobs_json_serialize_update_job_execution_request(
+                char *requestBuffer, size_t bufferSize,
+                const AwsIotJobExecutionUpdateRequest *request)
+{
+        const char *statusStr = aws_iot_jobs_map_status_to_string(request->status);
+        if (statusStr == NULL) return -1;
+        if (requestBuffer == NULL) bufferSize = 0;
+
+        struct _SerializeState state = { 0, requestBuffer, bufferSize };
+        _printKey(&state, true, "status");
+        _printStringValue(&state, statusStr);
+        if (request->statusDetails != NULL) {
+                _printKey(&state, false, "statusDetails");
+                _printToBuffer(&state, "%s", request->statusDetails);
+        }
+        if (request->executionNumber != 0) {
+                _printKey(&state, false, "executionNumber");
+                _printLongValue(&state, request->executionNumber);
+        }
+        if (request->expectedVersion != 0) {
+                _printKey(&state, false, "expectedVersion");
+                _printLongValue(&state, request->expectedVersion);
+        }
+        if (request->includeJobExecutionState) {
+                _printKey(&state, false, "includeJobExecutionState");
+                _printBooleanValue(&state, request->includeJobExecutionState);
+        }
+        if (request->includeJobDocument) {
+                _printKey(&state, false, "includeJobDocument");
+                _printBooleanValue(&state, request->includeJobDocument);
+        }
+        if (request->clientToken != NULL) {
+                _printKey(&state, false, "clientToken");
+                _printStringValue(&state, request->clientToken);
+        }
+
+        _printToBuffer(&state, "}");
+
+        return state.totalSize;
+}
+
+int aws_iot_jobs_json_serialize_client_token_only_request(
+                char *requestBuffer, size_t bufferSize,
+                const char *clientToken)
+{
+        struct _SerializeState state = { 0, requestBuffer, bufferSize };
+        _printKey(&state, true, "clientToken");
+        _printStringValue(&state, clientToken);
+        _printToBuffer(&state, "}");
+
+        return state.totalSize;
+}
+
+int aws_iot_jobs_json_serialize_describe_job_execution_request(
+                char *requestBuffer, size_t bufferSize,
+                const AwsIotDescribeJobExecutionRequest *request)
+{
+        bool first = true;
+
+        if (requestBuffer == NULL) return 0;
+
+        struct _SerializeState state = { 0, requestBuffer, bufferSize };
+        if (request->clientToken != NULL) {
+                _printKey(&state, first, "clientToken");
+                _printStringValue(&state, request->clientToken);
+                first = false;
+        }
+        if (request->executionNumber != 0) {
+                _printKey(&state, first, "executionNumber");
+                _printLongValue(&state, request->executionNumber);
+                first = false;
+        }
+        if (request->includeJobDocument) {
+                _printKey(&state, first, "includeJobDocument");
+                _printBooleanValue(&state, request->includeJobDocument);
+        }
+
+        _printToBuffer(&state, "}");
+
+        return state.totalSize;
+}
+
+int aws_iot_jobs_json_serialize_start_next_job_execution_request(
+                char *requestBuffer, size_t bufferSize,
+                const AwsIotStartNextPendingJobExecutionRequest *request)
+{
+        if (requestBuffer == NULL) bufferSize = 0;
+        struct _SerializeState state = { 0, requestBuffer, bufferSize };
+        if (request->statusDetails != NULL) {
+                _printKey(&state, true, "statusDetails");
+                _printToBuffer(&state, "%s", request->statusDetails);
+        }
+        if (request->clientToken != NULL) {
+                if(request->statusDetails != NULL) {
+                        _printKey(&state, false, "clientToken");
+                } else {
+                        _printKey(&state, true, "clientToken");
+                }
+                _printStringValue(&state, request->clientToken);
+        }
+        if (request->clientToken == NULL && request->statusDetails == NULL) {
+                _printToBuffer(&state, "{");
+        }
+        _printToBuffer(&state, "}");
+        return state.totalSize;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/aws_iot_jobs_topics.c b/src/aws_iot_jobs_topics.c
new file mode 100644
index 0000000..39c5cba
--- /dev/null
+++ b/src/aws_iot_jobs_topics.c
@@ -0,0 +1,129 @@
+/*
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+* http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file 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.
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "aws_iot_jobs_topics.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#define BASE_THINGS_TOPIC "$aws/things/"
+
+#define NOTIFY_OPERATION "notify"
+#define NOTIFY_NEXT_OPERATION "notify-next"
+#define GET_OPERATION "get"
+#define START_NEXT_OPERATION "start-next"
+#define WILDCARD_OPERATION "+"
+#define UPDATE_OPERATION "update"
+#define ACCEPTED_REPLY "accepted"
+#define REJECTED_REPLY "rejected"
+#define WILDCARD_REPLY "+"
+
+static const char *_get_operation_for_base_topic(AwsIotJobExecutionTopicType topicType) {
+        switch (topicType) {
+        case JOB_UPDATE_TOPIC:
+                return UPDATE_OPERATION;
+        case JOB_NOTIFY_TOPIC:
+                return NOTIFY_OPERATION;
+        case JOB_NOTIFY_NEXT_TOPIC:
+            return NOTIFY_NEXT_OPERATION;
+        case JOB_GET_PENDING_TOPIC:
+        case JOB_DESCRIBE_TOPIC:
+                return GET_OPERATION;
+        case JOB_START_NEXT_TOPIC:
+            return START_NEXT_OPERATION;
+        case JOB_WILDCARD_TOPIC:
+                return WILDCARD_OPERATION;
+        case JOB_UNRECOGNIZED_TOPIC:
+        default:
+                return NULL;
+        }
+}
+
+static bool _base_topic_requires_job_id(AwsIotJobExecutionTopicType topicType) {
+        switch (topicType) {
+        case JOB_UPDATE_TOPIC:
+        case JOB_DESCRIBE_TOPIC:
+                return true;
+        case JOB_NOTIFY_TOPIC:
+        case JOB_NOTIFY_NEXT_TOPIC:
+        case JOB_START_NEXT_TOPIC:
+        case JOB_GET_PENDING_TOPIC:
+        case JOB_WILDCARD_TOPIC:
+        case JOB_UNRECOGNIZED_TOPIC:
+        default:
+                return false;
+        }
+}
+
+static const char *_get_suffix_for_topic_type(AwsIotJobExecutionTopicReplyType replyType) {
+        switch (replyType) {
+        case JOB_REQUEST_TYPE:
+                return "";
+                break;
+        case JOB_ACCEPTED_REPLY_TYPE:
+                return "/" ACCEPTED_REPLY;
+                break;
+        case JOB_REJECTED_REPLY_TYPE:
+                return "/" REJECTED_REPLY;
+                break;
+        case JOB_WILDCARD_REPLY_TYPE:
+                return "/" WILDCARD_REPLY;
+                break;
+        case JOB_UNRECOGNIZED_TOPIC_TYPE:
+        default:
+                return NULL;
+        }
+}
+
+int aws_iot_jobs_get_api_topic(char *buffer, size_t bufferSize,
+                AwsIotJobExecutionTopicType topicType, AwsIotJobExecutionTopicReplyType replyType,
+                const char* thingName, const char* jobId)
+{
+        if (thingName == NULL) {
+                return -1;
+        }
+
+        if ((topicType == JOB_NOTIFY_TOPIC || topicType == JOB_NOTIFY_NEXT_TOPIC) && replyType != JOB_REQUEST_TYPE) {
+                return -1;
+        }
+
+        bool requireJobId = _base_topic_requires_job_id(topicType);
+        if (jobId == NULL && requireJobId) {
+                return -1;
+        }
+
+        const char *operation = _get_operation_for_base_topic(topicType);
+        if (operation == NULL) {
+                return -1;
+        }
+
+        const char *suffix = _get_suffix_for_topic_type(replyType);
+
+        if (requireJobId || (topicType == JOB_WILDCARD_TOPIC && jobId != NULL)) {
+                return snprintf(buffer, bufferSize, BASE_THINGS_TOPIC "%s/jobs/%s/%s%s", thingName, jobId, operation, suffix);
+        } else if (topicType == JOB_WILDCARD_TOPIC) {
+                return snprintf(buffer, bufferSize, BASE_THINGS_TOPIC "%s/jobs/#", thingName);
+        } else {
+                return snprintf(buffer, bufferSize, BASE_THINGS_TOPIC "%s/jobs/%s%s", thingName, operation, suffix);
+        }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/aws_iot_jobs_types.c b/src/aws_iot_jobs_types.c
new file mode 100644
index 0000000..9dcbf50
--- /dev/null
+++ b/src/aws_iot_jobs_types.c
@@ -0,0 +1,73 @@
+/*
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+* http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file 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.
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <string.h>
+#include "aws_iot_jobs_types.h"
+
+const char *JOB_EXECUTION_QUEUED_STR = "QUEUED";
+const char *JOB_EXECUTION_IN_PROGRESS_STR = "IN_PROGRESS";
+const char *JOB_EXECUTION_FAILED_STR = "FAILED";
+const char *JOB_EXECUTION_SUCCEEDED_STR = "SUCCEEDED";
+const char *JOB_EXECUTION_CANCELED_STR = "CANCELED";
+const char *JOB_EXECUTION_REJECTED_STR = "REJECTED";
+
+JobExecutionStatus aws_iot_jobs_map_string_to_job_status(const char *str) {
+        if (str == NULL || str[0] == '\0') {
+                return JOB_EXECUTION_STATUS_NOT_SET;
+        } else if (strcmp(str, JOB_EXECUTION_QUEUED_STR) == 0) {
+                return JOB_EXECUTION_QUEUED;
+        } else if(strcmp(str, JOB_EXECUTION_IN_PROGRESS_STR) == 0) {
+                return JOB_EXECUTION_IN_PROGRESS;
+        } else if(strcmp(str, JOB_EXECUTION_FAILED_STR) == 0) {
+                return JOB_EXECUTION_FAILED;
+        } else if(strcmp(str, JOB_EXECUTION_SUCCEEDED_STR) == 0) {
+                return JOB_EXECUTION_SUCCEEDED;
+        } else if(strcmp(str, JOB_EXECUTION_CANCELED_STR) == 0) {
+                return JOB_EXECUTION_CANCELED;
+        } else if(strcmp(str, JOB_EXECUTION_REJECTED_STR) == 0) {
+                return JOB_EXECUTION_REJECTED;
+        } else {
+                return JOB_EXECUTION_UNKNOWN_STATUS;
+        }
+}
+
+const char *aws_iot_jobs_map_status_to_string(JobExecutionStatus status) {
+        switch(status) {
+        case JOB_EXECUTION_QUEUED:
+                return JOB_EXECUTION_QUEUED_STR;
+        case JOB_EXECUTION_IN_PROGRESS:
+                return JOB_EXECUTION_IN_PROGRESS_STR;
+        case JOB_EXECUTION_FAILED:
+                return JOB_EXECUTION_FAILED_STR;
+        case JOB_EXECUTION_SUCCEEDED:
+                return JOB_EXECUTION_SUCCEEDED_STR;
+        case JOB_EXECUTION_CANCELED:
+                return JOB_EXECUTION_CANCELED_STR;
+        case JOB_EXECUTION_REJECTED:
+                return JOB_EXECUTION_REJECTED_STR;
+        case JOB_EXECUTION_STATUS_NOT_SET:
+        case JOB_EXECUTION_UNKNOWN_STATUS:
+        default:
+                return NULL;
+        }
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/aws_iot_json_utils.c b/src/aws_iot_json_utils.c
index 3a058f8..16a2609 100644
--- a/src/aws_iot_json_utils.c
+++ b/src/aws_iot_json_utils.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License").
  * You may not use this file except in compliance with the License.
@@ -196,6 +196,35 @@ IoT_Error_t parseStringValue(char *buf, const char *jsonString, jsmntok_t *token
         return SUCCESS;
 }
 
+jsmntok_t *findToken(const char *key, const char *jsonString, jsmntok_t *token) {
+        jsmntok_t *result = token;
+        int i;
+
+        if(token->type != JSMN_OBJECT) {
+                IOT_WARN("Token was not an object.");
+                return NULL;
+        }
+
+        if(token->size == 0) {
+                return NULL;
+        }
+
+        result = token + 1;
+
+        for (i = 0; i < token->size; i++) {
+                if (0 == jsoneq(jsonString, result, key)) {
+                        return result + 1;
+                }
+
+                int propertyEnd = (result + 1)->end;
+                result += 2;
+                while (result->start < propertyEnd)
+                        result++;
+        }
+
+        return NULL;
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/tests/integration/include/aws_iot_config.h b/tests/integration/include/aws_iot_config.h
index 5a3889c..2c80973 100644
--- a/tests/integration/include/aws_iot_config.h
+++ b/tests/integration/include/aws_iot_config.h
@@ -19,34 +19,49 @@
 // Get from console
 // =================================================
 #define AWS_IOT_MQTT_HOST              "" ///< Customer specific MQTT HOST. The same will be used for Thing Shadow
-#define AWS_IOT_MQTT_PORT              8883                                                                     ///< default port for MQTT/S
-#define AWS_IOT_MQTT_CLIENT_ID         "c-sdk-client-id"                                        ///< MQTT client ID should be unique for every device
-#define AWS_IOT_MY_THING_NAME          "AWS-IoT-C-SDK"                                          ///< Thing Name of the Shadow this device is associated with
-#define AWS_IOT_ROOT_CA_FILENAME       "rootCA.crt"                                                     ///< Root CA file name
-#define AWS_IOT_CERTIFICATE_FILENAME   "cert.pem"                                                       ///< device signed certificate file name
-#define AWS_IOT_PRIVATE_KEY_FILENAME   "privkey.pem"                                            ///< Device private key filename
-// =================================================
+#define AWS_IOT_MQTT_PORT              8883 ///< default port for MQTT/S
+#define AWS_IOT_MQTT_CLIENT_ID         "c-sdk-client-id" ///< MQTT client ID should be unique for every device
+#define AWS_IOT_MY_THING_NAME          "AWS-IoT-C-SDK" ///< Thing Name of the Shadow this device is associated with
+#define AWS_IOT_ROOT_CA_FILENAME       "rootCA.crt" ///< Root CA file name
+#define AWS_IOT_CERTIFICATE_FILENAME   "cert.pem" ///< device signed certificate file name
+#define AWS_IOT_PRIVATE_KEY_FILENAME   "privkey.pem" ///< Device private key filename
 
 // MQTT PubSub
-#define AWS_IOT_MQTT_TX_BUF_LEN 512                             ///< Any time a message is sent out through the MQTT layer. The message is copied into this buffer anytime a publish is done. This will also be used in the case of Thing Shadow
-#define AWS_IOT_MQTT_RX_BUF_LEN 512                             ///< Any message that comes into the device should be less than this buffer size. If a received message is bigger than this buffer size the message will be dropped.
-#define AWS_IOT_MQTT_NUM_SUBSCRIBE_HANDLERS 5   ///< Maximum number of topic filters the MQTT client can handle at any given time. This should be increased appropriately when using Thing Shadow
+#ifndef DISABLE_IOT_JOBS
+#define AWS_IOT_MQTT_RX_BUF_LEN 512 ///< Any message that comes into the device should be less than this buffer size. If a received message is bigger than this buffer size the message will be dropped.
+#else
+#define AWS_IOT_MQTT_RX_BUF_LEN 2048
+#endif
+#define AWS_IOT_MQTT_TX_BUF_LEN 512 ///< Any time a message is sent out through the MQTT layer. The message is copied into this buffer anytime a publish is done. This will also be used in the case of Thing Shadow
+#define AWS_IOT_MQTT_NUM_SUBSCRIBE_HANDLERS 5 ///< Maximum number of topic filters the MQTT client can handle at any given time. This should be increased appropriately when using Thing Shadow
+
+// Shadow and Job common configs
+#define MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES 80  ///< Maximum size of the Unique Client Id. For More info on the Client Id refer \ref response "Acknowledgments"
+#define MAX_SIZE_CLIENT_ID_WITH_SEQUENCE MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES + 10 ///< This is size of the extra sequence number that will be appended to the Unique client Id
+#define MAX_SIZE_CLIENT_TOKEN_CLIENT_SEQUENCE MAX_SIZE_CLIENT_ID_WITH_SEQUENCE + 20 ///< This is size of the the total clientToken key and value pair in the JSON
+#define MAX_SIZE_OF_THING_NAME 30 ///< The Thing Name should not be bigger than this value. Modify this if the Thing Name needs to be bigger
 
 // Thing Shadow specific configs
-#define SHADOW_MAX_SIZE_OF_RX_BUFFER (AWS_IOT_MQTT_RX_BUF_LEN+1)                                        ///< Maximum size of the SHADOW buffer to store the received Shadow message, including terminating NULL byte.
-#define MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES 80                                                                           ///< Maximum size of the Unique Client Id. For More info on the Client Id refer \ref response "Acknowledgments"
-#define MAX_SIZE_CLIENT_ID_WITH_SEQUENCE MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES + 10        ///< This is size of the extra sequence number that will be appended to the Unique client Id
-#define MAX_SIZE_CLIENT_TOKEN_CLIENT_SEQUENCE MAX_SIZE_CLIENT_ID_WITH_SEQUENCE + 20     ///< This is size of the the total clientToken key and value pair in the JSON
-#define MAX_ACKS_TO_COMEIN_AT_ANY_GIVEN_TIME 10                                                                         ///< At Any given time we will wait for this many responses. This will correlate to the rate at which the shadow actions are requested
-#define MAX_THINGNAME_HANDLED_AT_ANY_GIVEN_TIME 10                                                                      ///< We could perform shadow action on any thing Name and this is maximum Thing Names we can act on at any given time
-#define MAX_JSON_TOKEN_EXPECTED 120                                                                                                     ///< These are the max tokens that is expected to be in the Shadow JSON document. Include the metadata that gets published
-#define MAX_SHADOW_TOPIC_LENGTH_WITHOUT_THINGNAME 60                                                            ///< All shadow actions have to be published or subscribed to a topic which is of the format $aws/things/{thingName}/shadow/update/accepted. This refers to the size of the topic without the Thing Name
-#define MAX_SIZE_OF_THING_NAME 20                                                                                                       ///< The Thing Name should not be bigger than this value. Modify this if the Thing Name needs to be bigger
-#define MAX_SHADOW_TOPIC_LENGTH_BYTES MAX_SHADOW_TOPIC_LENGTH_WITHOUT_THINGNAME + MAX_SIZE_OF_THING_NAME        ///< This size includes the length of topic with Thing Name
+#define SHADOW_MAX_SIZE_OF_RX_BUFFER 512 ///< Maximum size of the SHADOW buffer to store the received Shadow message
+#define MAX_ACKS_TO_COMEIN_AT_ANY_GIVEN_TIME 10 ///< At Any given time we will wait for this many responses. This will correlate to the rate at which the shadow actions are requested
+#define MAX_THINGNAME_HANDLED_AT_ANY_GIVEN_TIME 10 ///< We could perform shadow action on any thing Name and this is maximum Thing Names we can act on at any given time
+#define MAX_JSON_TOKEN_EXPECTED 120 ///< These are the max tokens that is expected to be in the Shadow JSON document. Include the metadata that gets published
+#define MAX_SHADOW_TOPIC_LENGTH_WITHOUT_THINGNAME 60 ///< All shadow actions have to be published or subscribed to a topic which is of the format $aws/things/{thingName}/shadow/update/accepted. This refers to the size of the topic without the Thing Name
+#define MAX_SHADOW_TOPIC_LENGTH_BYTES MAX_SHADOW_TOPIC_LENGTH_WITHOUT_THINGNAME + MAX_SIZE_OF_THING_NAME ///< This size includes the length of topic with Thing Name
+
+// Job specific configs
+#ifndef DISABLE_IOT_JOBS
+#define MAX_SIZE_OF_JOB_ID 64
+#define MAX_JOB_JSON_TOKEN_EXPECTED 120
+#define MAX_SIZE_OF_JOB_REQUEST AWS_IOT_MQTT_TX_BUF_LEN
+
+#define MAX_JOB_TOPIC_LENGTH_WITHOUT_JOB_ID_OR_THING_NAME 40
+#define MAX_JOB_TOPIC_LENGTH_BYTES MAX_JOB_TOPIC_LENGTH_WITHOUT_JOB_ID_OR_THING_NAME + MAX_SIZE_OF_THING_NAME + MAX_SIZE_OF_JOB_ID + 2
+#endif
 
 // Auto Reconnect specific config
-#define AWS_IOT_MQTT_MIN_RECONNECT_WAIT_INTERVAL 1000           ///< Minimum time before the First reconnect attempt is made as part of the exponential back-off algorithm
-#define AWS_IOT_MQTT_MAX_RECONNECT_WAIT_INTERVAL 128000         ///< Maximum time interval after which exponential back-off will stop attempting to reconnect.
+#define AWS_IOT_MQTT_MIN_RECONNECT_WAIT_INTERVAL 1000 ///< Minimum time before the First reconnect attempt is made as part of the exponential back-off algorithm
+#define AWS_IOT_MQTT_MAX_RECONNECT_WAIT_INTERVAL 128000 ///< Maximum time interval after which exponential back-off will stop attempting to reconnect.
 
 #define DISABLE_METRICS false ///< Disable the collection of metrics by setting this to true
 
diff --git a/tests/integration/src/aws_iot_test_integration_runner.c b/tests/integration/src/aws_iot_test_integration_runner.c
index 5ce5bd0..61ec00f 100644
--- a/tests/integration/src/aws_iot_test_integration_runner.c
+++ b/tests/integration/src/aws_iot_test_integration_runner.c
@@ -1,5 +1,5 @@
 /*
-* Copyright 2015-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@
 
 int main() {
         int rc = 0;
+
         printf("\n\n");
         printf("*************************************************************************************************\n");
         printf("* Starting TEST 1 MQTT Version 3.1.1 Basic Subscribe QoS 1 Publish QoS 1 with Single Client     *\n");
@@ -34,7 +35,7 @@ int main() {
                 return 1;
         }
         printf("\n*************************************************************************************************\n");
-        printf("* Test 1 MQTT Version 3.1.1 Basic Subscribe QoS 1 Publish QoS 1 with Single Client SUCCESS!!    *\n");
+        printf("* TEST 1 MQTT Version 3.1.1 Basic Subscribe QoS 1 Publish QoS 1 with Single Client SUCCESS!!    *\n");
         printf("*************************************************************************************************\n");
 
         printf("\n\n");
@@ -67,5 +68,24 @@ int main() {
         printf("* TEST 3 MQTT Version 3.1.1 Auto Reconnect SUCCESS!!     *\n");
         printf("**********************************************************\n");
 
+#ifndef DISABLE_IOT_JOBS
+#ifndef DISABLE_IOT_JOBS_INTERFACE
+        printf("\n\n");
+        printf("*************************************************************************************************\n");
+        printf("* Starting TEST 4 Jobs API Test                                                                 *\n");
+        printf("*************************************************************************************************\n");
+        rc = aws_iot_jobs_basic_test();
+        if(0 != rc) {
+                printf("\n********************************************************************************************************\n");
+                printf("* TEST 4 Jobs API Test  FAILED! RC : %4d                                                              *\n", rc);
+                printf("********************************************************************************************************\n");
+                return 1;
+        }
+        printf("\n*************************************************************************************************\n");
+        printf("* TEST 4 Jobs API Test SUCCESS!!                                                                *\n");
+        printf("*************************************************************************************************\n");
+#endif
+#endif
+
         return 0;
 }
diff --git a/tests/integration/src/aws_iot_test_jobs_api.c b/tests/integration/src/aws_iot_test_jobs_api.c
new file mode 100644
index 0000000..a7e4ce0
--- /dev/null
+++ b/tests/integration/src/aws_iot_test_jobs_api.c
@@ -0,0 +1,279 @@
+/*
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+* http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file 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.
+*/
+
+#ifndef DISABLE_IOT_JOBS
+#ifndef DISABLE_IOT_JOBS_INTERFACE
+
+#include "aws_iot_test_integration_common.h"
+#include <aws_iot_jobs_interface.h>
+#include <aws_iot_jobs_json.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <assert.h>
+
+static AWS_IoT_Client client;
+
+static jsmn_parser jsonParser;
+static jsmntok_t jsonTokenStruct[MAX_JSON_TOKEN_EXPECTED];
+static int32_t tokenCount;
+
+static void aws_iot_mqtt_tests_disconnect_callback_handler(AWS_IoT_Client *pClient, void *param) {
+}
+
+void iot_get_pending_callback_handler(AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen,
+                                                                        IoT_Publish_Message_Params *params, void *pData) {
+        IoT_Error_t rc = SUCCESS;
+        char topicToPublishGetNext[MAX_JOB_TOPIC_LENGTH_BYTES];
+
+        IOT_UNUSED(pData);
+        IOT_UNUSED(pClient);
+        IOT_INFO("\nJOB_GET_PENDING_TOPIC callback");
+        IOT_INFO("topic: %.*s", topicNameLen, topicName);
+        IOT_INFO("payload: %.*s", (int) params->payloadLen, (char *)params->payload);
+
+        jsmn_init(&jsonParser);
+
+        tokenCount = jsmn_parse(&jsonParser, params->payload, (int) params->payloadLen, jsonTokenStruct, MAX_JSON_TOKEN_EXPECTED);
+
+        if(tokenCount < 0) {
+                IOT_WARN("Failed to parse JSON: %d", tokenCount);
+                return;
+        }
+
+        /* Assume the top-level element is an object */
+        if(tokenCount < 1 || jsonTokenStruct[0].type != JSMN_OBJECT) {
+                IOT_WARN("Top Level is not an object");
+                return;
+        }
+
+        jsmntok_t *jobs;
+
+        jobs = findToken("inProgressJobs", params->payload, jsonTokenStruct);
+
+        if (jobs) {
+                IOT_INFO("inProgressJobs: %.*s", jobs->end - jobs->start, (char *)params->payload + jobs->start);               
+        }       
+
+        jobs = findToken("queuedJobs", params->payload, jsonTokenStruct);
+
+        if (jobs) {
+                IOT_INFO("queuedJobs: %.*s", jobs->end - jobs->start, (char *)params->payload + jobs->start);           
+        }
+
+        AwsIotDescribeJobExecutionRequest describeRequest;
+        describeRequest.executionNumber = 0;
+        describeRequest.includeJobDocument = true;
+        describeRequest.clientToken = NULL;
+
+        rc = aws_iot_jobs_describe(&client, QOS0, AWS_IOT_MY_THING_NAME, JOB_ID_NEXT, &describeRequest, topicToPublishGetNext, sizeof(topicToPublishGetNext), NULL, 0);
+}
+
+void iot_next_job_callback_handler(AWS_IoT_Client *pClient, char *topicName, uint16_t topicNameLen,
+                                                                        IoT_Publish_Message_Params *params, void *pData) {
+        char topicToPublishUpdate[MAX_JOB_TOPIC_LENGTH_BYTES];
+        char messageBuffer[200];
+
+        IOT_UNUSED(pClient);
+        IOT_INFO("\nJOB_NOTIFY_NEXT_TOPIC / JOB_DESCRIBE_TOPIC($next) callback");
+        IOT_INFO("topic: %.*s", topicNameLen, topicName);
+        IOT_INFO("payload: %.*s", (int) params->payloadLen, (char *)params->payload);
+
+        jsmn_init(&jsonParser);
+
+        tokenCount = jsmn_parse(&jsonParser, params->payload, (int) params->payloadLen, jsonTokenStruct, MAX_JSON_TOKEN_EXPECTED);
+
+        if(tokenCount < 0) {
+                IOT_WARN("Failed to parse JSON: %d", tokenCount);
+                return;
+        }
+
+        /* Assume the top-level element is an object */
+        if(tokenCount < 1 || jsonTokenStruct[0].type != JSMN_OBJECT) {
+                IOT_WARN("Top Level is not an object");
+                return;
+        }
+
+        jsmntok_t *tokExecution;
+
+        tokExecution = findToken("execution", params->payload, jsonTokenStruct);
+
+        if (tokExecution) {
+                IOT_INFO("execution: %.*s", tokExecution->end - tokExecution->start, (char *)params->payload + tokExecution->start);
+
+                jsmntok_t *tok;
+
+                tok = findToken("jobId", params->payload, tokExecution);
+
+                if (tok) {
+                        IoT_Error_t rc;
+                        char jobId[MAX_SIZE_OF_JOB_ID + 1];
+                        AwsIotJobExecutionUpdateRequest updateRequest;
+
+                        rc = parseStringValue(jobId, params->payload, tok);                     
+                        if(SUCCESS != rc) {
+                                IOT_ERROR("parseStringValue returned error : %d ", rc);
+                                return;
+                        }
+
+                        IOT_INFO("jobId: %s", jobId);
+
+                        tok = findToken("jobDocument", params->payload, tokExecution);
+
+                        /*
+                         * Do your job processing here.
+                         */
+
+                        if (tok) {
+                                IOT_INFO("jobDocument: %.*s", tok->end - tok->start, (char *)params->payload + tok->start);
+                                /* Alternatively if the job still has more steps the status can be set to JOB_EXECUTION_IN_PROGRESS instead */
+                                updateRequest.status = JOB_EXECUTION_SUCCEEDED;
+                                updateRequest.statusDetails = "{\"exampleDetail\":\"a value appropriate for your successful job\"}";
+                        } else {
+                                updateRequest.status = JOB_EXECUTION_FAILED;
+                                updateRequest.statusDetails = "{\"failureDetail\":\"Unable to process job document\"}";
+                        }
+
+                        updateRequest.expectedVersion = 0;
+                        updateRequest.executionNumber = 0;
+                        updateRequest.includeJobExecutionState = false;
+                        updateRequest.includeJobDocument = false;
+                        updateRequest.clientToken = NULL;
+
+                        rc = aws_iot_jobs_send_update(pClient, QOS0, AWS_IOT_MY_THING_NAME, jobId, &updateRequest, 
+                                        topicToPublishUpdate, sizeof(topicToPublishUpdate), messageBuffer, sizeof(messageBuffer));
+                }
+        } else {
+                IOT_INFO("execution property not found, nothing to do, jobs integration test complete");
+                
+                bool *callbackDone = (bool *) pData;
+                *callbackDone = true;
+        }
+}
+
+int aws_iot_jobs_basic_test() {
+        char certDirectory[15] = "../../certs";
+        char clientCRT[PATH_MAX + 1];
+        char root_CA[PATH_MAX + 1];
+        char clientKey[PATH_MAX + 1];
+        char CurrentWD[PATH_MAX + 1];
+        char clientId[50];
+        char cPayload[100];
+        IoT_Client_Init_Params initParams;
+        IoT_Client_Connect_Params connectParams;
+        IoT_Publish_Message_Params paramsQOS0;
+        IoT_Error_t rc = SUCCESS;
+        struct timeval connectTime;
+        struct timeval start, end;
+        unsigned int connectCounter = 0;
+
+        IOT_DEBUG("\nConnecting Client ");
+        do {
+                getcwd(CurrentWD, sizeof(CurrentWD));
+                snprintf(root_CA, PATH_MAX + 1, "%s/%s/%s", CurrentWD, certDirectory, AWS_IOT_ROOT_CA_FILENAME);
+                snprintf(clientCRT, PATH_MAX + 1, "%s/%s/%s", CurrentWD, certDirectory, AWS_IOT_CERTIFICATE_FILENAME);
+                snprintf(clientKey, PATH_MAX + 1, "%s/%s/%s", CurrentWD, certDirectory, AWS_IOT_PRIVATE_KEY_FILENAME);
+                srand((unsigned int)time(NULL));
+                snprintf(clientId, 50, "%s_%d", INTEGRATION_TEST_CLIENT_ID, rand() % 10000);
+
+                printf("\n\nClient ID : %s \n", clientId);
+
+                IOT_DEBUG("Root CA Path : %s\n clientCRT : %s\n clientKey : %s\n", root_CA, clientCRT, clientKey);
+                initParams.pHostURL = AWS_IOT_MQTT_HOST;
+                initParams.port = 8883;
+                initParams.pRootCALocation = root_CA;
+                initParams.pDeviceCertLocation = clientCRT;
+                initParams.pDevicePrivateKeyLocation = clientKey;
+                initParams.mqttCommandTimeout_ms = 10000;
+                initParams.tlsHandshakeTimeout_ms = 10000;
+                initParams.disconnectHandler = aws_iot_mqtt_tests_disconnect_callback_handler;
+                initParams.enableAutoReconnect = false;
+                aws_iot_mqtt_init(&client, &initParams);
+
+                connectParams.keepAliveIntervalInSec = 10;
+                connectParams.isCleanSession = true;
+                connectParams.MQTTVersion = MQTT_3_1_1;
+                connectParams.pClientID = (char *)&clientId;
+                connectParams.clientIDLen = strlen(clientId);
+                connectParams.isWillMsgPresent = false;
+                connectParams.pUsername = NULL;
+                connectParams.usernameLen = 0;
+                connectParams.pPassword = NULL;
+                connectParams.passwordLen = 0;
+
+                gettimeofday(&connectTime, NULL);
+                rc = aws_iot_mqtt_connect(&client, &connectParams);
+                gettimeofday(&end, NULL);
+                timersub(&end, &start, &connectTime);
+
+                connectCounter++;
+        } while(rc != SUCCESS && connectCounter < CONNECT_MAX_ATTEMPT_COUNT);
+
+        if(SUCCESS == rc) {
+                IOT_DEBUG("## Connect Success. Time sec: %d, usec: %d\n", connectTime.tv_sec, connectTime.tv_usec);
+        } else {
+                IOT_ERROR("## Connect Failed. error code %d\n", rc);
+                return -1;
+        }
+
+        bool callbackDone = false;
+        char topicToSubscribeGetPending[MAX_JOB_TOPIC_LENGTH_BYTES];
+        char topicToSubscribeNotifyNext[MAX_JOB_TOPIC_LENGTH_BYTES];
+        char topicToSubscribeGetNext[MAX_JOB_TOPIC_LENGTH_BYTES];
+
+        char topicToPublishGetPending[MAX_JOB_TOPIC_LENGTH_BYTES];
+
+        rc = aws_iot_jobs_subscribe_to_job_messages(
+                &client, QOS0, AWS_IOT_MY_THING_NAME, NULL, JOB_GET_PENDING_TOPIC, JOB_WILDCARD_REPLY_TYPE,
+                iot_get_pending_callback_handler, &callbackDone, topicToSubscribeGetPending, sizeof(topicToSubscribeGetPending));
+
+        if(SUCCESS != rc) {
+                IOT_ERROR("Error subscribing JOB_GET_PENDING_TOPIC: %d ", rc);
+                return rc;
+        }
+
+        rc = aws_iot_jobs_subscribe_to_job_messages(
+                &client, QOS0, AWS_IOT_MY_THING_NAME, NULL, JOB_NOTIFY_NEXT_TOPIC, JOB_REQUEST_TYPE,
+                iot_next_job_callback_handler, &callbackDone, topicToSubscribeNotifyNext, sizeof(topicToSubscribeNotifyNext));
+
+        if(SUCCESS != rc) {
+                IOT_ERROR("Error subscribing JOB_NOTIFY_NEXT_TOPIC: %d ", rc);
+                return rc;
+        }
+
+        rc = aws_iot_jobs_subscribe_to_job_messages(
+                &client, QOS0, AWS_IOT_MY_THING_NAME, JOB_ID_NEXT, JOB_DESCRIBE_TOPIC, JOB_WILDCARD_REPLY_TYPE,
+                iot_next_job_callback_handler, &callbackDone, topicToSubscribeGetNext, sizeof(topicToSubscribeGetNext));
+
+        if(SUCCESS != rc) {
+                IOT_ERROR("Error subscribing JOB_DESCRIBE_TOPIC ($next): %d ", rc);
+                return rc;
+        }
+
+        paramsQOS0.qos = QOS0;
+        paramsQOS0.payload = (void *) cPayload;
+        paramsQOS0.isRetained = 0;
+        paramsQOS0.payloadLen = strlen(cPayload);
+
+        rc = aws_iot_jobs_send_query(&client, QOS0, AWS_IOT_MY_THING_NAME, NULL, NULL, topicToPublishGetPending, sizeof(topicToPublishGetPending), NULL, 0, JOB_GET_PENDING_TOPIC);
+
+        while (!callbackDone) {
+                aws_iot_mqtt_yield(&client, 5000);
+        }
+
+        return 0;
+}
+
+#endif
+#endif
diff --git a/tests/unit/include/aws_iot_config.h b/tests/unit/include/aws_iot_config.h
index e22db06..248baed 100644
--- a/tests/unit/include/aws_iot_config.h
+++ b/tests/unit/include/aws_iot_config.h
@@ -32,26 +32,42 @@
 #define AWS_IOT_PRIVATE_KEY_FILENAME   "privkey.pem"
 // =================================================
 
+
 // MQTT PubSub
-#define AWS_IOT_MQTT_TX_BUF_LEN 512
-#define AWS_IOT_MQTT_RX_BUF_LEN 512
-#define AWS_IOT_MQTT_NUM_SUBSCRIBE_HANDLERS 5
+#ifndef DISABLE_IOT_JOBS
+#define AWS_IOT_MQTT_RX_BUF_LEN 512 ///< Any message that comes into the device should be less than this buffer size. If a received message is bigger than this buffer size the message will be dropped.
+#else
+#define AWS_IOT_MQTT_RX_BUF_LEN 2048
+#endif
+#define AWS_IOT_MQTT_TX_BUF_LEN 512 ///< Any time a message is sent out through the MQTT layer. The message is copied into this buffer anytime a publish is done. This will also be used in the case of Thing Shadow
+#define AWS_IOT_MQTT_NUM_SUBSCRIBE_HANDLERS 5 ///< Maximum number of topic filters the MQTT client can handle at any given time. This should be increased appropriately when using Thing Shadow
+
+// Shadow and Job common configs
+#define MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES 80  ///< Maximum size of the Unique Client Id. For More info on the Client Id refer \ref response "Acknowledgments"
+#define MAX_SIZE_CLIENT_ID_WITH_SEQUENCE MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES + 10 ///< This is size of the extra sequence number that will be appended to the Unique client Id
+#define MAX_SIZE_CLIENT_TOKEN_CLIENT_SEQUENCE MAX_SIZE_CLIENT_ID_WITH_SEQUENCE + 20 ///< This is size of the the total clientToken key and value pair in the JSON
+#define MAX_SIZE_OF_THING_NAME 30 ///< The Thing Name should not be bigger than this value. Modify this if the Thing Name needs to be bigger
 
 // Thing Shadow specific configs
-#define SHADOW_MAX_SIZE_OF_RX_BUFFER 512
-#define MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES 80  /** {"clientToken": ">>uniqueClientID<<+sequenceNumber"}*/
-#define MAX_SIZE_CLIENT_ID_WITH_SEQUENCE MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES + 10 /** {"clientToken": ">>uniqueClientID+sequenceNumber<<"}*/
-#define MAX_SIZE_CLIENT_TOKEN_CLIENT_SEQUENCE MAX_SIZE_CLIENT_ID_WITH_SEQUENCE + 20 /** >>{"clientToken": "uniqueClientID+sequenceNumber"}<<*/
-#define MAX_SIZE_OF_THINGNAME 30
-#define MAX_ACKS_TO_COMEIN_AT_ANY_GIVEN_TIME 10
-#define MAX_THINGNAME_HANDLED_AT_ANY_GIVEN_TIME 10
-#define MAX_JSON_TOKEN_EXPECTED 120
-#define MAX_SHADOW_TOPIC_LENGTH_WITHOUT_THINGNAME 60
-#define MAX_SIZE_OF_THING_NAME 20
-#define MAX_SHADOW_TOPIC_LENGTH_BYTES MAX_SHADOW_TOPIC_LENGTH_WITHOUT_THINGNAME + MAX_SIZE_OF_THING_NAME
+#define SHADOW_MAX_SIZE_OF_RX_BUFFER 512 ///< Maximum size of the SHADOW buffer to store the received Shadow message
+#define MAX_ACKS_TO_COMEIN_AT_ANY_GIVEN_TIME 10 ///< At Any given time we will wait for this many responses. This will correlate to the rate at which the shadow actions are requested
+#define MAX_THINGNAME_HANDLED_AT_ANY_GIVEN_TIME 10 ///< We could perform shadow action on any thing Name and this is maximum Thing Names we can act on at any given time
+#define MAX_JSON_TOKEN_EXPECTED 120 ///< These are the max tokens that is expected to be in the Shadow JSON document. Include the metadata that gets published
+#define MAX_SHADOW_TOPIC_LENGTH_WITHOUT_THINGNAME 60 ///< All shadow actions have to be published or subscribed to a topic which is of the format $aws/things/{thingName}/shadow/update/accepted. This refers to the size of the topic without the Thing Name
+#define MAX_SHADOW_TOPIC_LENGTH_BYTES MAX_SHADOW_TOPIC_LENGTH_WITHOUT_THINGNAME + MAX_SIZE_OF_THING_NAME ///< This size includes the length of topic with Thing Name
+
+// Job specific configs
+#ifndef DISABLE_IOT_JOBS
+#define MAX_SIZE_OF_JOB_ID 64
+#define MAX_JOB_JSON_TOKEN_EXPECTED 120
+#define MAX_SIZE_OF_JOB_REQUEST AWS_IOT_MQTT_TX_BUF_LEN
+
+#define MAX_JOB_TOPIC_LENGTH_WITHOUT_JOB_ID_OR_THING_NAME 40
+#define MAX_JOB_TOPIC_LENGTH_BYTES MAX_JOB_TOPIC_LENGTH_WITHOUT_JOB_ID_OR_THING_NAME + MAX_SIZE_OF_THING_NAME + MAX_SIZE_OF_JOB_ID + 2
+#endif
 
 // Auto Reconnect specific config
-#define AWS_IOT_MQTT_MIN_RECONNECT_WAIT_INTERVAL 1000
-#define AWS_IOT_MQTT_MAX_RECONNECT_WAIT_INTERVAL 128000
+#define AWS_IOT_MQTT_MIN_RECONNECT_WAIT_INTERVAL 1000 ///< Minimum time before the First reconnect attempt is made as part of the exponential back-off algorithm
+#define AWS_IOT_MQTT_MAX_RECONNECT_WAIT_INTERVAL 128000 ///< Maximum time interval after which exponential back-off will stop attempting to reconnect.
 
 #endif /* IOT_TESTS_UNIT_CONFIG_H_ */
diff --git a/tests/unit/include/aws_iot_tests_unit_helper_functions.h b/tests/unit/include/aws_iot_tests_unit_helper_functions.h
index d8a1806..a7d3f80 100644
--- a/tests/unit/include/aws_iot_tests_unit_helper_functions.h
+++ b/tests/unit/include/aws_iot_tests_unit_helper_functions.h
@@ -23,6 +23,7 @@
 
 #include <string.h>
 #include "aws_iot_mqtt_client_interface.h"
+#include "aws_iot_jobs_topics.h"
 
 typedef struct {
         unsigned char PacketType;
@@ -92,4 +93,8 @@ bool isConnectTxBufPayloadCorrect(IoT_Client_Connect_Params *settings, unsigned
 
 void printPrfrdParams(ConnectBufferProofread *params);
 
+const char *getJobTopicTypeName(AwsIotJobExecutionTopicType topicType);
+
+const char *getJobReplyTypeName(AwsIotJobExecutionTopicReplyType replyType);
+
 #endif /* IOT_TESTS_UNIT_HELPER_FUNCTIONS_H_ */
diff --git a/tests/unit/src/aws_iot_tests_unit_common_tests_helper.c b/tests/unit/src/aws_iot_tests_unit_common_tests_helper.c
index e7a852e..9d16042 100644
--- a/tests/unit/src/aws_iot_tests_unit_common_tests_helper.c
+++ b/tests/unit/src/aws_iot_tests_unit_common_tests_helper.c
@@ -131,7 +131,7 @@ TEST_C(CommonTests, UnexpectedAckFiltering) {
 TEST_C(CommonTests, BigMQTTRxMessageIgnore) {
         uint32_t i = 0;
         IoT_Error_t rc = FAILURE;
-        char expectedCallbackString[AWS_IOT_MQTT_TX_BUF_LEN + 2];
+        char expectedCallbackString[AWS_IOT_MQTT_RX_BUF_LEN + 2];
 
         IOT_DEBUG("\n-->Running CommonTests - Ignore Large Incoming Message \n");
 
@@ -139,7 +139,7 @@ TEST_C(CommonTests, BigMQTTRxMessageIgnore) {
         rc = aws_iot_mqtt_subscribe(&iotClient, "limitTest/topic1", 16, QOS0, iot_tests_unit_common_subscribe_callback_handler, NULL);
         CHECK_EQUAL_C_INT(SUCCESS, rc);
 
-        for(i = 0; i < AWS_IOT_MQTT_TX_BUF_LEN; i++) {
+        for(i = 0; i < AWS_IOT_MQTT_RX_BUF_LEN; i++) {
                 expectedCallbackString[i] = 'X';
         }
         expectedCallbackString[i + 1] = '\0';
@@ -156,7 +156,7 @@ TEST_C(CommonTests, BigMQTTRxMessageIgnore) {
 TEST_C(CommonTests, BigMQTTRxMessageReadNextMessage) {
         uint32_t i = 0;
         IoT_Error_t rc = FAILURE;
-        char expectedCallbackString[AWS_IOT_MQTT_TX_BUF_LEN + 2];
+        char expectedCallbackString[AWS_IOT_MQTT_RX_BUF_LEN + 2];
 
         IOT_DEBUG("\n-->Running CommonTests - Clear Buffer when large message received and continue reading \n");
 
@@ -164,7 +164,7 @@ TEST_C(CommonTests, BigMQTTRxMessageReadNextMessage) {
         rc = aws_iot_mqtt_subscribe(&iotClient, "limitTest/topic1", 16, QOS0, iot_tests_unit_common_subscribe_callback_handler, NULL);
         CHECK_EQUAL_C_INT(SUCCESS, rc);
 
-        for(i = 0; i < AWS_IOT_MQTT_TX_BUF_LEN; i++) {
+        for(i = 0; i < AWS_IOT_MQTT_RX_BUF_LEN; i++) {
                 expectedCallbackString[i] = 'X';
         }
         expectedCallbackString[i + 1] = '\0';
diff --git a/tests/unit/src/aws_iot_tests_unit_helper_functions.c b/tests/unit/src/aws_iot_tests_unit_helper_functions.c
index afa676d..428bc29 100644
--- a/tests/unit/src/aws_iot_tests_unit_helper_functions.c
+++ b/tests/unit/src/aws_iot_tests_unit_helper_functions.c
@@ -536,3 +536,28 @@ void printPrfrdParams(ConnectBufferProofread *params) {
         printf("KeepAliveInterval: %u\n", params->KeepAlive);
         printf("----------------\n");
 }
+
+const char *getJobTopicTypeName(AwsIotJobExecutionTopicType topicType) {
+        switch (topicType) {
+        case JOB_UPDATE_TOPIC:                  return "JOB_UPDATE_TOPIC";
+        case JOB_NOTIFY_TOPIC:                  return "JOB_NOTIFY_TOPIC";
+        case JOB_NOTIFY_NEXT_TOPIC:             return "JOB_NOTIFY_NEXT_TOPIC";
+        case JOB_GET_PENDING_TOPIC:             return "JOB_GET_PENDING_TOPIC";
+        case JOB_DESCRIBE_TOPIC:                return "JOB_DESCRIBE_TOPIC";
+        case JOB_START_NEXT_TOPIC:              return "JOB_START_NEXT_TOPIC";
+        case JOB_WILDCARD_TOPIC:                return "JOB_WILDCARD_TOPIC";
+        case JOB_UNRECOGNIZED_TOPIC:    return "JOB_UNRECOGNIZED_TOPIC";
+        default:                                                return "invalid";
+        }
+}
+
+const char *getJobReplyTypeName(AwsIotJobExecutionTopicReplyType replyType) {
+        switch (replyType) {
+        case JOB_REQUEST_TYPE:                          return "JOB_REQUEST_TYPE";
+        case JOB_ACCEPTED_REPLY_TYPE:           return "JOB_ACCEPTED_REPLY_TYPE";
+        case JOB_REJECTED_REPLY_TYPE:           return "JOB_REJECTED_REPLY_TYPE";
+        case JOB_WILDCARD_REPLY_TYPE:           return "JOB_WILDCARD_REPLY_TYPE";
+        case JOB_UNRECOGNIZED_TOPIC_TYPE:       return "JOB_UNRECOGNIZED_TOPIC_TYPE";
+        default:                                                        return "invalid";
+        }
+}
diff --git a/tests/unit/src/aws_iot_tests_unit_jobs.cpp b/tests/unit/src/aws_iot_tests_unit_jobs.cpp
new file mode 100644
index 0000000..edbf8ce
--- /dev/null
+++ b/tests/unit/src/aws_iot_tests_unit_jobs.cpp
@@ -0,0 +1,60 @@
+/*
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+* http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file 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.
+*/
+
+#include <CppUTest/CommandLineTestRunner.h>
+#include <CppUTest/TestHarness_c.h>
+
+
+TEST_GROUP_C(JobsTypesTests) {
+  TEST_GROUP_C_SETUP_WRAPPER(JobsTypesTests)
+  TEST_GROUP_C_TEARDOWN_WRAPPER(JobsTypesTests)
+};
+
+TEST_GROUP_C_WRAPPER(JobsTypesTests, StringToStatus)
+TEST_GROUP_C_WRAPPER(JobsTypesTests, StatusToString)
+
+TEST_GROUP_C(JobsJsonTests) {
+  TEST_GROUP_C_SETUP_WRAPPER(JobsJsonTests)
+  TEST_GROUP_C_TEARDOWN_WRAPPER(JobsJsonTests)
+};
+
+TEST_GROUP_C_WRAPPER(JobsJsonTests, SerializeUpdateRequest)
+TEST_GROUP_C_WRAPPER(JobsJsonTests, SerializeUpdateRequestWithNullBuffer)
+TEST_GROUP_C_WRAPPER(JobsJsonTests, SerializeUpdateRequestWithTooSmallBuffer)
+TEST_GROUP_C_WRAPPER(JobsJsonTests, SerializeDescribeJobExecutionRequest)
+TEST_GROUP_C_WRAPPER(JobsJsonTests, SerializeDescribeJobExecutionRequestWithNullBuffer)
+TEST_GROUP_C_WRAPPER(JobsJsonTests, SerializeDescribeJobExecutionRequestWithTooSmallBuffer)
+TEST_GROUP_C_WRAPPER(JobsJsonTests, SerializeStartNextRequest)
+TEST_GROUP_C_WRAPPER(JobsJsonTests, SerializeStartNextRequestWithNullBuffer)
+TEST_GROUP_C_WRAPPER(JobsJsonTests, SerializeStartNextRequestWithTooSmallBuffer)
+
+TEST_GROUP_C(JobsTopicsTests) {
+  TEST_GROUP_C_SETUP_WRAPPER(JobsTopicsTests)
+  TEST_GROUP_C_TEARDOWN_WRAPPER(JobsTopicsTests)
+};
+
+TEST_GROUP_C_WRAPPER(JobsTopicsTests, GenerateValidTopics)
+TEST_GROUP_C_WRAPPER(JobsTopicsTests, GenerateWithMissingJobId)
+TEST_GROUP_C_WRAPPER(JobsTopicsTests, GenerateWithInvalidTopicOrReplyType)
+TEST_GROUP_C_WRAPPER(JobsTopicsTests, GenerateWithInvalidCombinations)
+
+TEST_GROUP_C(JobsInterfaceTest) {
+        TEST_GROUP_C_SETUP_WRAPPER(JobsInterfaceTest)
+        TEST_GROUP_C_TEARDOWN_WRAPPER(JobsInterfaceTest)
+};
+
+TEST_GROUP_C_WRAPPER(JobsInterfaceTest, TestSubscribeAndUnsubscribe)
+TEST_GROUP_C_WRAPPER(JobsInterfaceTest, TestSendQuery)
+TEST_GROUP_C_WRAPPER(JobsInterfaceTest, TestSendUpdate)
diff --git a/tests/unit/src/aws_iot_tests_unit_jobs_interface.c b/tests/unit/src/aws_iot_tests_unit_jobs_interface.c
new file mode 100644
index 0000000..c19a38d
--- /dev/null
+++ b/tests/unit/src/aws_iot_tests_unit_jobs_interface.c
@@ -0,0 +1,337 @@
+/*
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+* http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file 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.
+*/
+
+#include <aws_iot_jobs_interface.h>
+
+#include "aws_iot_tests_unit_mock_tls_params.h"
+#include "aws_iot_tests_unit_helper_functions.h"
+#include "aws_iot_config.h"
+#include <aws_iot_tests_unit_helper_functions.h>
+#include <CppUTest/TestHarness_c.h>
+#include <aws_iot_log.h>
+
+static AWS_IoT_Client client;
+static IoT_Client_Connect_Params connectParams;
+static IoT_Client_Init_Params mqttInitParams;
+
+static const char *THING_NAME = "T1";
+static const char *JOB_ID = "J1";
+
+static int CALLBACK_DATA = 5;
+
+static const char *expectedTopic;
+static const void *expectedData;
+static size_t expectedDataLen;
+
+static int callbackCount = 0;
+
+static bool expectError;
+static bool expectedJsonContext;
+
+
+static void testCallback(
+                        AWS_IoT_Client *pClient,
+                        char *topicName, uint16_t topicNameLen,
+                        IoT_Publish_Message_Params *params, void *pData)
+{
+        callbackCount++;
+
+        CHECK_C(pData == &CALLBACK_DATA);
+        CHECK_C(pClient == &client);
+
+        CHECK_EQUAL_C_INT((int)strlen(expectedTopic), (int)topicNameLen);
+        CHECK_C(strncmp(expectedTopic, topicName, (size_t) topicNameLen) == 0);
+
+        CHECK_C(memcmp(expectedData, params->payload, expectedDataLen) == 0);
+}
+
+TEST_GROUP_C_SETUP(JobsInterfaceTest) {
+        IoT_Error_t ret_val = SUCCESS;
+
+        InitMQTTParamsSetup(&mqttInitParams, AWS_IOT_MQTT_HOST, AWS_IOT_MQTT_PORT, false, NULL);
+        ret_val = aws_iot_mqtt_init(&client, &mqttInitParams);
+        CHECK_EQUAL_C_INT(SUCCESS, ret_val);
+
+        ConnectMQTTParamsSetup(&connectParams, (char *) AWS_IOT_MQTT_CLIENT_ID, (uint16_t) strlen(AWS_IOT_MQTT_CLIENT_ID));
+        setTLSRxBufferForConnack(&connectParams, 0, 0);
+        ret_val = aws_iot_mqtt_connect(&client, &connectParams);
+        CHECK_EQUAL_C_INT(SUCCESS, ret_val);
+
+        ResetTLSBuffer();
+
+        /* Ensure that old data can't be used */
+        lastSubscribeMsgLen = 0;
+        lastUnsubscribeMsgLen = 0;
+        lastPublishMessageTopicLen = 0;
+        lastPublishMessagePayloadLen = 0;
+
+        callbackCount = 0;
+        expectedTopic = NULL;
+        expectedData = NULL;
+        expectedDataLen = 0;
+
+        expectError = false;
+        expectedJsonContext = false;
+}
+
+TEST_GROUP_C_TEARDOWN(JobsInterfaceTest) {
+        IoT_Error_t rc = aws_iot_mqtt_disconnect(&client);
+        IOT_UNUSED(rc);
+}
+
+static void publishTestMessage(AwsIotJobExecutionTopicType topicType, bool withJobId) {
+        char replyTopic[MAX_JOB_TOPIC_LENGTH_BYTES + 1];
+        AwsIotJobExecutionTopicReplyType replyType;
+        char * message;
+
+        if (topicType == JOB_NOTIFY_TOPIC) {
+                replyType = JOB_REQUEST_TYPE;
+                message = "{\"jobs\":{\"IN_PROGRESS\":[{}]},\"timestamp\":5}";
+        } else if (topicType == JOB_NOTIFY_NEXT_TOPIC) {
+                replyType = JOB_REQUEST_TYPE;
+                message = "{\"execution\":{\"jobId\":\"J1\",\"status\":\"IN_PROGRESS\",\"queuedAt\":50,\"versionNumber\":20},\"timestamp\":5}";
+        }
+        else {
+                replyType = JOB_REJECTED_REPLY_TYPE;
+                message = "{\"code\":\"foo\",\"message\":\"bar\", \"clientToken\":\"baz\",\"timestamp\":6}";
+        }
+
+        const char *passedJobId = NULL;
+        if (withJobId) {
+                if (topicType == JOB_WILDCARD_TOPIC) {
+                        topicType = JOB_DESCRIBE_TOPIC;
+                }
+                passedJobId = JOB_ID;
+        }
+
+        int replyTopicLen = aws_iot_jobs_get_api_topic(
+                        replyTopic, MAX_JOB_TOPIC_LENGTH_BYTES + 1,
+                                        topicType, replyType, THING_NAME, passedJobId);
+
+        expectedData = message;
+        expectedDataLen = strlen(message) + 1;
+        expectedTopic = replyTopic;
+
+        IoT_Publish_Message_Params params;
+        params.payload = message;
+        params.payloadLen = strlen(message);
+        params.qos = QOS0;
+
+        int preSendCount = callbackCount;
+
+        setTLSRxBufferWithMsgOnSubscribedTopic(replyTopic, (size_t)replyTopicLen, QOS0, params, message);
+        IoT_Error_t error = aws_iot_mqtt_yield(&client, 100);
+
+        CHECK_EQUAL_C_INT(SUCCESS, error);
+        CHECK_EQUAL_C_INT(preSendCount + 1, callbackCount);
+}
+
+static void testSubscribeAndUnsubscribe(AwsIotJobExecutionTopicType topicType, bool withJobId) {
+        char expectedTopic[MAX_JOB_TOPIC_LENGTH_BYTES + 1];
+        char topicBuffer[MAX_JOB_TOPIC_LENGTH_BYTES + 1];
+
+        IOT_DEBUG("\n-->Running Jobs Interface Tests - test subscribe/unsubscribe %s %s \n", getJobTopicTypeName(topicType), (withJobId ? "(w/ job id)" : ""));
+
+        AwsIotJobExecutionTopicReplyType replyType;
+        if (topicType != JOB_NOTIFY_TOPIC && topicType != JOB_NOTIFY_NEXT_TOPIC) {
+                replyType = JOB_WILDCARD_REPLY_TYPE;
+        } else {
+                replyType = JOB_REQUEST_TYPE;
+        }
+
+        const char *passedJobId = NULL;
+        if (withJobId) passedJobId = JOB_ID;
+
+        int expectedTopicLength = aws_iot_jobs_get_api_topic(
+                        expectedTopic, MAX_JOB_TOPIC_LENGTH_BYTES + 1,
+                                        topicType, replyType,
+                                        THING_NAME, passedJobId);
+
+        CHECK_C(expectedTopicLength > 0 && expectedTopicLength < MAX_JOB_TOPIC_LENGTH_BYTES);
+
+        /* Clear to make sure old data doesn't cause the test to pass when we shouldn't */
+        lastSubscribeMsgLen = 0;
+        lastPublishMessageTopicLen = 0;
+
+        IoT_Publish_Message_Params unused;
+
+        setTLSRxBufferForSuback(expectedTopic, (size_t)expectedTopicLength, QOS0, unused);
+
+        IoT_Error_t iotError;
+        if (topicType == JOB_WILDCARD_TOPIC && !withJobId) {
+                iotError = aws_iot_jobs_subscribe_to_all_job_messages(
+                                &client, QOS0, THING_NAME, testCallback, &CALLBACK_DATA, topicBuffer, sizeof(topicBuffer));
+        } else {
+                iotError = aws_iot_jobs_subscribe_to_job_messages(
+                                &client, QOS0, THING_NAME, passedJobId, topicType, replyType, testCallback, &CALLBACK_DATA, topicBuffer, sizeof(topicBuffer));
+        }
+
+        CHECK_EQUAL_C_INT(SUCCESS, iotError);
+
+        CHECK_EQUAL_C_INT(expectedTopicLength, (int)strlen(topicBuffer));
+        CHECK_EQUAL_C_INT(expectedTopicLength, (int)lastSubscribeMsgLen);
+        CHECK_EQUAL_C_STRING(expectedTopic, topicBuffer);
+        CHECK_EQUAL_C_STRING(expectedTopic, LastSubscribeMessage);
+
+        publishTestMessage(topicType, withJobId);
+
+        LastUnsubscribeMessage[0] = 0;
+        lastUnsubscribeMsgLen = 0;
+
+        setTLSRxBufferForUnsuback();
+        iotError = aws_iot_jobs_unsubscribe_from_job_messages(&client, topicBuffer);
+
+        CHECK_EQUAL_C_INT(SUCCESS, iotError);
+
+        CHECK_EQUAL_C_STRING(expectedTopic, LastUnsubscribeMessage);
+
+        IOT_DEBUG("-->Success - test subscribe/unsubscribe %s %s \n", getJobTopicTypeName(topicType), (withJobId ? "(w/ job id)" : ""));
+}
+
+TEST_C(JobsInterfaceTest, TestSubscribeAndUnsubscribe) {
+        testSubscribeAndUnsubscribe(JOB_NOTIFY_TOPIC, false);
+        testSubscribeAndUnsubscribe(JOB_NOTIFY_NEXT_TOPIC, false);
+        testSubscribeAndUnsubscribe(JOB_DESCRIBE_TOPIC, true);
+        testSubscribeAndUnsubscribe(JOB_GET_PENDING_TOPIC, false);
+        testSubscribeAndUnsubscribe(JOB_UPDATE_TOPIC, true);
+        testSubscribeAndUnsubscribe(JOB_WILDCARD_TOPIC, true);
+        testSubscribeAndUnsubscribe(JOB_WILDCARD_TOPIC, false);
+        testSubscribeAndUnsubscribe(JOB_START_NEXT_TOPIC, false);
+}
+
+static void testSendQuery(bool withJobId, bool withClientToken, AwsIotJobExecutionTopicType topicType) {
+        char expectedTopic[MAX_JOB_TOPIC_LENGTH_BYTES + 1];
+        char topicBuffer[MAX_JOB_TOPIC_LENGTH_BYTES + 1];
+        char messageBuffer[MAX_SIZE_OF_JOB_REQUEST + 1];
+
+        IOT_DEBUG("\n-->Running Jobs Interface Tests - test send query %s %s \n", getJobTopicTypeName(topicType), (withClientToken ? "(w/ clientToken)" : ""));
+
+        char *clientToken = NULL;
+        char *bufferToPass = NULL;
+        size_t bufferLenToPass = 0;
+        if (withClientToken) {
+                clientToken = "FooBar";
+                bufferToPass = messageBuffer;
+                bufferLenToPass = MAX_SIZE_OF_JOB_REQUEST + 1;
+        }
+
+        const char *passedJobId = NULL;
+        if (withJobId) passedJobId = JOB_ID;
+
+        int expectedTopicLength = aws_iot_jobs_get_api_topic(
+                        expectedTopic, MAX_JOB_TOPIC_LENGTH_BYTES + 1,
+                        topicType, JOB_REQUEST_TYPE,
+                        THING_NAME, passedJobId);
+
+        CHECK_C(expectedTopicLength > 0 && expectedTopicLength <= MAX_JOB_TOPIC_LENGTH_BYTES);
+
+        LastPublishMessageTopic[0] = 0;
+        lastPublishMessageTopicLen = 0;
+        LastPublishMessagePayload[0] = 0;
+        lastPublishMessagePayloadLen = 0;
+
+        setTLSRxBufferForPuback();
+        IoT_Error_t iotError;
+
+        if (topicType == JOB_DESCRIBE_TOPIC) {
+                AwsIotDescribeJobExecutionRequest request;
+                request.executionNumber = 0;
+                request.includeJobDocument = false;
+                request.clientToken = clientToken;
+
+                iotError = aws_iot_jobs_describe(
+                                &client, QOS0, THING_NAME, passedJobId, &request, topicBuffer, sizeof(topicBuffer), bufferToPass, bufferLenToPass);
+        } else if (topicType == JOB_START_NEXT_TOPIC) {
+                AwsIotStartNextPendingJobExecutionRequest request;
+                request.statusDetails = NULL;
+                request.clientToken = clientToken;
+
+                iotError = aws_iot_jobs_start_next(
+                                &client, QOS0, THING_NAME, &request, topicBuffer, sizeof(topicBuffer), messageBuffer, sizeof(messageBuffer));
+        } else {
+                iotError = aws_iot_jobs_send_query(
+                                &client, QOS0, THING_NAME, passedJobId, clientToken, topicBuffer, sizeof(topicBuffer), bufferToPass, bufferLenToPass, topicType);
+        }
+
+        CHECK_EQUAL_C_INT(SUCCESS, iotError);
+        CHECK_EQUAL_C_INT(expectedTopicLength, (int)lastPublishMessageTopicLen);
+        CHECK_EQUAL_C_STRING(expectedTopic, LastPublishMessageTopic);
+
+        if (withClientToken) {
+                CHECK_EQUAL_C_INT((int)strlen(LastPublishMessagePayload), (int)lastPublishMessagePayloadLen);
+                CHECK_EQUAL_C_STRING("{\"clientToken\":\"FooBar\"}", LastPublishMessagePayload);
+        } else if (topicType == JOB_START_NEXT_TOPIC) {
+                CHECK_EQUAL_C_INT(2, (int)lastPublishMessagePayloadLen);
+                CHECK_EQUAL_C_STRING("{}", LastPublishMessagePayload);
+        } else {
+                CHECK_EQUAL_C_INT(0, (int)lastPublishMessagePayloadLen);
+        }
+
+        IOT_DEBUG("-->Success - test send query %s %s \n", getJobTopicTypeName(topicType), (withClientToken ? "(w/ clientToken)" : ""));
+}
+
+TEST_C(JobsInterfaceTest, TestSendQuery) {
+        int token;
+        for (token = 0; token < 2; ++token) {
+                testSendQuery(false, token == 0, JOB_GET_PENDING_TOPIC);
+                testSendQuery(true, token == 0, JOB_DESCRIBE_TOPIC);
+                testSendQuery(false, token == 0, JOB_START_NEXT_TOPIC);
+        }
+}
+
+TEST_C(JobsInterfaceTest, TestSendUpdate) {
+        AwsIotJobExecutionUpdateRequest updateRequest;
+        updateRequest.clientToken = "FooBar";
+        updateRequest.status = JOB_EXECUTION_SUCCEEDED;
+        updateRequest.expectedVersion = 1;
+        updateRequest.executionNumber = 0;
+        updateRequest.statusDetails = NULL;
+        updateRequest.includeJobExecutionState = false;
+        updateRequest.includeJobDocument = false;
+
+        char expectedTopic[MAX_JOB_TOPIC_LENGTH_BYTES + 1];
+        char topicBuffer[MAX_JOB_TOPIC_LENGTH_BYTES + 1];
+        char messageBuffer[AWS_IOT_MQTT_TX_BUF_LEN + 1];
+
+        IOT_DEBUG("\n-->Running Jobs Interface Tests - test send update \n");
+
+        int expectedTopicLength = aws_iot_jobs_get_api_topic(
+                        expectedTopic, MAX_JOB_TOPIC_LENGTH_BYTES + 1,
+                        JOB_UPDATE_TOPIC, JOB_REQUEST_TYPE,
+                        THING_NAME, JOB_ID);
+
+        CHECK_C(expectedTopicLength > 0 && expectedTopicLength <= MAX_JOB_TOPIC_LENGTH_BYTES);
+
+        LastPublishMessageTopic[0] = 0;
+        lastPublishMessageTopicLen = 0;
+        LastPublishMessagePayload[0] = 0;
+        lastPublishMessagePayloadLen = 0;
+
+        setTLSRxBufferForPuback();
+        IoT_Error_t iotError;
+        iotError = aws_iot_jobs_send_update(
+                        &client, QOS0, THING_NAME, JOB_ID, &updateRequest,
+                        topicBuffer, sizeof(topicBuffer),
+                        messageBuffer, sizeof(messageBuffer));
+
+        CHECK_EQUAL_C_INT(SUCCESS, iotError);
+
+        CHECK_EQUAL_C_INT(expectedTopicLength, (int)lastPublishMessageTopicLen);
+        CHECK_EQUAL_C_STRING(expectedTopic, LastPublishMessageTopic);
+
+        CHECK_EQUAL_C_STRING("{\"status\":\"SUCCEEDED\",\"expectedVersion\":1,\"clientToken\":\"FooBar\"}", LastPublishMessagePayload);
+
+        IOT_DEBUG("-->Success - test send update \n");
+}
diff --git a/tests/unit/src/aws_iot_tests_unit_jobs_json.c b/tests/unit/src/aws_iot_tests_unit_jobs_json.c
new file mode 100644
index 0000000..5a04554
--- /dev/null
+++ b/tests/unit/src/aws_iot_tests_unit_jobs_json.c
@@ -0,0 +1,244 @@
+/*
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+* http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file 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.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <CppUTest/TestHarness_c.h>
+#include <aws_iot_jobs_json.h>
+#include <aws_iot_tests_unit_helper_functions.h>
+#include <aws_iot_log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NUM_TOKENS 50
+
+static jsmntok_t tokens[NUM_TOKENS];
+
+TEST_GROUP_C_SETUP(JobsJsonTests) {
+}
+
+TEST_GROUP_C_TEARDOWN(JobsJsonTests) {
+}
+
+static const char *defaultUpdateRequestSerialized =
+                "{\"status\":\"IN_PROGRESS\",\"statusDetails\":{\"Step\":\"1\",\"StepStatus\":\"Foo\"},"
+                "\"executionNumber\":2,\"expectedVersion\":1,\"includeJobExecutionState\":true,\"includeJobDocument\":true,\"clientToken\":\"1234\"}";
+
+static void fillDefaultUpdateRequest(AwsIotJobExecutionUpdateRequest *request)
+{
+        request->status = JOB_EXECUTION_IN_PROGRESS;
+        request->statusDetails = "{\"Step\":\"1\",\"StepStatus\":\"Foo\"}";
+        request->expectedVersion = 1;
+        request->executionNumber = 2;
+        request->includeJobExecutionState = true;
+        request->includeJobDocument = true;
+        request->clientToken = "1234";
+}
+
+TEST_C(JobsJsonTests, SerializeUpdateRequest) {
+        AwsIotJobExecutionUpdateRequest updateRequest;
+
+        IOT_DEBUG("\n-->Running Jobs Json Tests - serialize update request \n");
+
+        fillDefaultUpdateRequest(&updateRequest);
+
+        char buffer[256];
+        int charsUsed = aws_iot_jobs_json_serialize_update_job_execution_request(buffer, sizeof(buffer), &updateRequest);
+        CHECK_EQUAL_C_INT((int)strlen(defaultUpdateRequestSerialized), charsUsed);
+        CHECK_EQUAL_C_STRING(defaultUpdateRequestSerialized, buffer);
+
+        jsmn_parser parser;
+        jsmn_init(&parser);
+
+        int num_parsed_tokens = jsmn_parse(&parser, buffer, (size_t)charsUsed, tokens, NUM_TOKENS);
+        CHECK_C(num_parsed_tokens > 0);
+
+        IOT_DEBUG("-->Success - serialize update request \n");
+}
+
+TEST_C(JobsJsonTests, SerializeUpdateRequestWithNullBuffer) {
+        AwsIotJobExecutionUpdateRequest updateRequest;
+
+        IOT_DEBUG("\n-->Running Jobs Json Tests - serialize update request w/ null buffer \n");
+
+        fillDefaultUpdateRequest(&updateRequest);
+
+        int charsUsed = aws_iot_jobs_json_serialize_update_job_execution_request(NULL, 0, &updateRequest);
+        CHECK_EQUAL_C_INT((int)strlen(defaultUpdateRequestSerialized), charsUsed);
+
+        IOT_DEBUG("-->Success - serialize update request w/ null buffer \n");
+}
+
+TEST_C(JobsJsonTests, SerializeUpdateRequestWithTooSmallBuffer) {
+        AwsIotJobExecutionUpdateRequest updateRequest;
+
+        IOT_DEBUG("\n-->Running Jobs Json Tests - serialize update request w/ too small buffer \n");
+
+        fillDefaultUpdateRequest(&updateRequest);
+
+        char buffer[11];
+        // A check character which shouldn't be overwritten as we pass a length of 10
+        buffer[10] = -1;
+
+        int charsUsed = aws_iot_jobs_json_serialize_update_job_execution_request(buffer, 10, &updateRequest);
+        CHECK_EQUAL_C_INT((int)strlen(defaultUpdateRequestSerialized), charsUsed);
+
+        CHECK_EQUAL_C_CHAR(-1, buffer[10]);
+        CHECK_EQUAL_C_CHAR(0, buffer[9]);
+        // 9 because the 10th is \0
+        CHECK_C(strncmp(defaultUpdateRequestSerialized, buffer, 9) == 0);
+
+        IOT_DEBUG("-->Success - serialize update request w/ too small buffer \n");
+}
+
+static void fillDefaultDescribeJobExecutionRequest(
+                AwsIotDescribeJobExecutionRequest *request)
+{
+        request->executionNumber = 1;
+        request->includeJobDocument = true;
+        request->clientToken = "1234";
+}
+
+static const char *defaultDescribeJobExecutionRequestSerialized =
+                "{\"clientToken\":\"1234\",\"executionNumber\":1,\"includeJobDocument\":true}";
+
+TEST_C(JobsJsonTests, SerializeDescribeJobExecutionRequest) {
+        AwsIotDescribeJobExecutionRequest describeJobExecutionRequest;
+
+        IOT_DEBUG("\n-->Running Jobs Json Tests - serialize describe job execution request \n");
+
+        fillDefaultDescribeJobExecutionRequest(&describeJobExecutionRequest);
+
+        char buffer[256];
+        int charsUsed = aws_iot_jobs_json_serialize_describe_job_execution_request(buffer, 256, &describeJobExecutionRequest);
+        CHECK_EQUAL_C_INT((int)strlen(defaultDescribeJobExecutionRequestSerialized), charsUsed);
+
+        CHECK_EQUAL_C_STRING(defaultDescribeJobExecutionRequestSerialized, buffer);
+
+        jsmn_parser parser;
+        jsmn_init(&parser);
+
+        int num_parsed_tokens = jsmn_parse(&parser, buffer, (size_t)charsUsed, tokens, NUM_TOKENS);
+        CHECK_C(num_parsed_tokens > 0);
+
+        IOT_DEBUG("-->Success - serialize describe job execution request \n");
+}
+
+TEST_C(JobsJsonTests, SerializeDescribeJobExecutionRequestWithNullBuffer) {
+        AwsIotDescribeJobExecutionRequest describeJobExecutionRequest;
+
+        IOT_DEBUG("\n-->Running Jobs Json Tests - serialize describe job execution request w/ null buffer \n");
+
+        fillDefaultDescribeJobExecutionRequest(&describeJobExecutionRequest);
+
+        int charsUsed = aws_iot_jobs_json_serialize_describe_job_execution_request(NULL, 0, &describeJobExecutionRequest);
+        CHECK_EQUAL_C_INT(0, charsUsed);
+
+        IOT_DEBUG("-->Success - serialize describe job execution request w/ null buffer \n");
+}
+
+TEST_C(JobsJsonTests, SerializeDescribeJobExecutionRequestWithTooSmallBuffer) {
+        AwsIotDescribeJobExecutionRequest describeJobExecutionRequest;
+
+        IOT_DEBUG("\n-->Running Jobs Json Tests - serialize describe job execution request w/ too small buffer \n");
+
+        fillDefaultDescribeJobExecutionRequest(&describeJobExecutionRequest);
+
+        char buffer[11];
+        // A check character which shouldn't be overwritten as we pass a length of 10
+        buffer[10] = -1;
+
+        int charsUsed = aws_iot_jobs_json_serialize_describe_job_execution_request(buffer, 10, &describeJobExecutionRequest);
+        CHECK_EQUAL_C_INT((int)strlen(defaultDescribeJobExecutionRequestSerialized), charsUsed);
+
+        CHECK_EQUAL_C_CHAR(-1, buffer[10]);
+        CHECK_EQUAL_C_CHAR(0, buffer[9]);
+        // 9 because the 10th is \0
+        CHECK_C(strncmp(defaultDescribeJobExecutionRequestSerialized, buffer, 9) == 0);
+
+        IOT_DEBUG("-->Success - serialize describe job execution request w/ too small buffer \n");
+}
+
+static void fillDefaultStartNextRequest(AwsIotStartNextPendingJobExecutionRequest *request)
+{
+        request->statusDetails = "{\"Step\":\"1\",\"StepStatus\":\"Foo\"}";
+        request->clientToken = "1234";
+}
+
+static const char *defaultStartNextRequestSerialized =
+                "{\"statusDetails\":{\"Step\":\"1\",\"StepStatus\":\"Foo\"},\"clientToken\":\"1234\"}";
+
+TEST_C(JobsJsonTests, SerializeStartNextRequest) {
+        AwsIotStartNextPendingJobExecutionRequest startNextRequest;
+        fillDefaultStartNextRequest(&startNextRequest);
+
+        IOT_DEBUG("\n-->Running Jobs Json Tests - serialize start next request \n");
+
+        char buffer[256];
+        int charsUsed = aws_iot_jobs_json_serialize_start_next_job_execution_request(buffer, 256, &startNextRequest);
+        CHECK_EQUAL_C_INT((int)strlen(defaultStartNextRequestSerialized), charsUsed);
+
+        CHECK_EQUAL_C_STRING(defaultStartNextRequestSerialized, buffer);
+        jsmn_parser parser;
+        jsmn_init(&parser);
+
+        int num_parsed_tokens = jsmn_parse(&parser, buffer, (size_t)charsUsed, tokens, NUM_TOKENS);
+        CHECK_C(num_parsed_tokens > 0);
+
+        IOT_DEBUG("-->Success - serialize start next request \n");
+}
+
+TEST_C(JobsJsonTests, SerializeStartNextRequestWithNullBuffer) {
+        AwsIotStartNextPendingJobExecutionRequest startNextRequest;
+
+        IOT_DEBUG("\n-->Running Jobs Json Tests - serialize start next request w/ null buffer \n");
+
+        fillDefaultStartNextRequest(&startNextRequest);
+
+        int charsUsed = aws_iot_jobs_json_serialize_start_next_job_execution_request(NULL, 0, &startNextRequest);
+        CHECK_EQUAL_C_INT((int)strlen(defaultStartNextRequestSerialized), charsUsed);
+
+        IOT_DEBUG("-->Success - serialize start next request w/ null buffer \n");
+}
+
+TEST_C(JobsJsonTests, SerializeStartNextRequestWithTooSmallBuffer) {
+        AwsIotStartNextPendingJobExecutionRequest startNextRequest;
+
+        IOT_DEBUG("\n-->Running Jobs Json Tests - serialize start next request w/ too small buffer \n");
+
+        fillDefaultStartNextRequest(&startNextRequest);
+
+        char buffer[11];
+        // A check character which shouldn't be overwritten as we pass a length of 10
+        buffer[10] = -1;
+
+        int charsUsed = aws_iot_jobs_json_serialize_start_next_job_execution_request(buffer, 10, &startNextRequest);
+        CHECK_EQUAL_C_INT((int) strlen(defaultStartNextRequestSerialized), charsUsed);
+
+        CHECK_EQUAL_C_CHAR(-1, buffer[10]);
+        CHECK_EQUAL_C_CHAR(0, buffer[9]);
+        // 9 because the 10th is \0
+        CHECK_C(strncmp(defaultStartNextRequestSerialized, buffer, 9) == 0);
+
+        IOT_DEBUG("-->Success - serialize start next request w/ too small buffer \n");
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/tests/unit/src/aws_iot_tests_unit_jobs_topics.c b/tests/unit/src/aws_iot_tests_unit_jobs_topics.c
new file mode 100644
index 0000000..b6c6ace
--- /dev/null
+++ b/tests/unit/src/aws_iot_tests_unit_jobs_topics.c
@@ -0,0 +1,161 @@
+/*
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+* http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file 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.
+*/
+
+#include "aws_iot_jobs_topics.h"
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <CppUTest/TestHarness_c.h>
+#include <aws_iot_tests_unit_helper_functions.h>
+#include <aws_iot_log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+TEST_GROUP_C_SETUP(JobsTopicsTests) {
+}
+
+TEST_GROUP_C_TEARDOWN(JobsTopicsTests) {
+}
+
+#define TEST_THING_NAME "TestThing"
+#define TEST_TOPIC_PREFIX "$aws/things/" TEST_THING_NAME "/jobs"
+#define TEST_JOB_ID "TestJob"
+#define TEST_NEXT_JOB_ID "$next"
+#define TEST_TOPIC_W_JOB_PREFIX TEST_TOPIC_PREFIX "/" TEST_JOB_ID
+
+static int generateTopicForTestThingAndJob(
+                char *buffer, size_t bufferSize,
+                AwsIotJobExecutionTopicType topicType, AwsIotJobExecutionTopicReplyType replyType)
+{
+        return aws_iot_jobs_get_api_topic(
+                        buffer, bufferSize, topicType, replyType, TEST_THING_NAME, TEST_JOB_ID);
+}
+
+static int generateTopicForTestThing(
+                char *buffer, size_t bufferSize,
+                AwsIotJobExecutionTopicType topicType, AwsIotJobExecutionTopicReplyType replyType)
+{
+        return aws_iot_jobs_get_api_topic(
+                        buffer, bufferSize, topicType, replyType, TEST_THING_NAME, NULL);
+}
+
+static void testGenerateValidApiTopic(
+                AwsIotJobExecutionTopicType topicType, AwsIotJobExecutionTopicReplyType replyType,
+                bool includeThingName, const char *expectedOutput)
+{
+        int requestedSize;
+        int expectedSize = (int)strlen(expectedOutput);
+
+        IOT_DEBUG("\n-->Running Jobs Topics Tests - generate valid topics %s w/ reply type \n", getJobTopicTypeName(topicType), getJobReplyTypeName(replyType));
+
+        if (includeThingName) {
+                requestedSize = generateTopicForTestThingAndJob(NULL, 0, topicType, replyType);
+                CHECK_EQUAL_C_INT(expectedSize, requestedSize);
+        } else {
+                requestedSize = generateTopicForTestThing(NULL, 0, topicType, replyType);
+                CHECK_EQUAL_C_INT(expectedSize, requestedSize);
+        }
+
+        CHECK_C(requestedSize > 3);
+        char *buffer = (char *) malloc((size_t)(requestedSize + 1) * sizeof(char));
+        buffer[3] = -1;
+
+        if (includeThingName) {
+                requestedSize = generateTopicForTestThingAndJob(buffer, 3, topicType, replyType);
+        } else {
+                requestedSize = generateTopicForTestThing(buffer, 3, topicType, replyType);
+        }
+        CHECK_EQUAL_C_INT(expectedSize, requestedSize);
+
+        CHECK_EQUAL_C_CHAR(expectedOutput[0], buffer[0]);
+        CHECK_EQUAL_C_CHAR(expectedOutput[1], buffer[1]);
+        CHECK_EQUAL_C_CHAR('\0', buffer[2]);
+        CHECK_EQUAL_C_CHAR(-1, buffer[3]);
+
+        if (includeThingName) {
+                requestedSize = generateTopicForTestThingAndJob(buffer, (size_t)requestedSize + 1, topicType, replyType);
+        } else {
+                requestedSize = generateTopicForTestThing(buffer, (size_t)requestedSize + 1, topicType, replyType);
+        }
+
+        CHECK_EQUAL_C_INT(expectedSize, requestedSize);
+        CHECK_EQUAL_C_STRING(expectedOutput, buffer);
+
+        free(buffer);
+
+        IOT_DEBUG("-->Success - generate valid topics %s w/ reply type \n", getJobTopicTypeName(topicType), getJobReplyTypeName(replyType));
+}
+
+static void testGenerateValidApiTopicWithAllReplyTypes(
+                AwsIotJobExecutionTopicType topicType, bool includeThingName,
+                const char *expectedBaseTopic)
+{
+        char buffer[1024];
+
+        testGenerateValidApiTopic(
+                        topicType, JOB_REQUEST_TYPE, includeThingName, expectedBaseTopic);
+
+        snprintf(buffer, 1024, "%s/accepted", expectedBaseTopic);
+        testGenerateValidApiTopic(
+                                topicType, JOB_ACCEPTED_REPLY_TYPE, includeThingName, buffer);
+
+        snprintf(buffer, 1024, "%s/rejected", expectedBaseTopic);
+        testGenerateValidApiTopic(
+                                topicType, JOB_REJECTED_REPLY_TYPE, includeThingName, buffer);
+
+        snprintf(buffer, 1024, "%s/+", expectedBaseTopic);
+        testGenerateValidApiTopic(
+                                topicType, JOB_WILDCARD_REPLY_TYPE, includeThingName, buffer);
+
+}
+
+TEST_C(JobsTopicsTests, GenerateValidTopics) {
+        testGenerateValidApiTopicWithAllReplyTypes(JOB_UPDATE_TOPIC, true, TEST_TOPIC_W_JOB_PREFIX "/update");
+        testGenerateValidApiTopicWithAllReplyTypes(JOB_DESCRIBE_TOPIC, true, TEST_TOPIC_W_JOB_PREFIX "/get");
+        testGenerateValidApiTopicWithAllReplyTypes(JOB_WILDCARD_TOPIC, true, TEST_TOPIC_W_JOB_PREFIX "/+");
+        testGenerateValidApiTopic(JOB_WILDCARD_TOPIC, JOB_REQUEST_TYPE, false, TEST_TOPIC_PREFIX "/#");
+        testGenerateValidApiTopic(JOB_NOTIFY_TOPIC, JOB_REQUEST_TYPE, false, TEST_TOPIC_PREFIX "/notify");
+        testGenerateValidApiTopic(JOB_NOTIFY_NEXT_TOPIC, JOB_REQUEST_TYPE, false, TEST_TOPIC_PREFIX "/notify-next");
+        testGenerateValidApiTopic(JOB_START_NEXT_TOPIC, JOB_REQUEST_TYPE, false, TEST_TOPIC_PREFIX "/start-next");
+}
+
+TEST_C(JobsTopicsTests, GenerateWithMissingJobId) {
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_UPDATE_TOPIC, JOB_REQUEST_TYPE));
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_DESCRIBE_TOPIC, JOB_REQUEST_TYPE));
+}
+
+TEST_C(JobsTopicsTests, GenerateWithInvalidTopicOrReplyType) {
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_UNRECOGNIZED_TOPIC, JOB_REQUEST_TYPE));
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, -1, JOB_REQUEST_TYPE));
+
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_DESCRIBE_TOPIC, JOB_UNRECOGNIZED_TOPIC_TYPE));
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_DESCRIBE_TOPIC, -1));
+}
+
+TEST_C(JobsTopicsTests, GenerateWithInvalidCombinations) {
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_NOTIFY_TOPIC, JOB_ACCEPTED_REPLY_TYPE));
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_NOTIFY_TOPIC, JOB_REJECTED_REPLY_TYPE));
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_NOTIFY_TOPIC, JOB_WILDCARD_REPLY_TYPE));
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_NOTIFY_NEXT_TOPIC, JOB_ACCEPTED_REPLY_TYPE));
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_NOTIFY_NEXT_TOPIC, JOB_REJECTED_REPLY_TYPE));
+        CHECK_EQUAL_C_INT(-1, generateTopicForTestThing(NULL, 0, JOB_NOTIFY_NEXT_TOPIC, JOB_WILDCARD_REPLY_TYPE));
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/tests/unit/src/aws_iot_tests_unit_jobs_types.c b/tests/unit/src/aws_iot_tests_unit_jobs_types.c
new file mode 100644
index 0000000..60dc8c9
--- /dev/null
+++ b/tests/unit/src/aws_iot_tests_unit_jobs_types.c
@@ -0,0 +1,70 @@
+/*
+* Copyright 2015-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+* http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file 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.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <CppUTest/TestHarness_c.h>
+#include <aws_iot_jobs_types.h>
+#include <aws_iot_tests_unit_helper_functions.h>
+#include <aws_iot_log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+TEST_GROUP_C_SETUP(JobsTypesTests) {
+}
+
+TEST_GROUP_C_TEARDOWN(JobsTypesTests) {
+}
+
+TEST_C(JobsTypesTests, StringToStatus) {
+        char emptyString = '\0';
+
+        IOT_DEBUG("\n-->Running Jobs Types Tests - string to status \n");
+
+        CHECK_EQUAL_C_INT((int)JOB_EXECUTION_STATUS_NOT_SET, (int)aws_iot_jobs_map_string_to_job_status(NULL));
+        CHECK_EQUAL_C_INT((int)JOB_EXECUTION_STATUS_NOT_SET, (int)aws_iot_jobs_map_string_to_job_status(&emptyString));
+        CHECK_EQUAL_C_INT((int)JOB_EXECUTION_QUEUED, (int)aws_iot_jobs_map_string_to_job_status("QUEUED"));
+        CHECK_EQUAL_C_INT((int)JOB_EXECUTION_IN_PROGRESS, (int)aws_iot_jobs_map_string_to_job_status("IN_PROGRESS"));
+        CHECK_EQUAL_C_INT((int)JOB_EXECUTION_FAILED, (int)aws_iot_jobs_map_string_to_job_status("FAILED"));
+        CHECK_EQUAL_C_INT((int)JOB_EXECUTION_SUCCEEDED, (int)aws_iot_jobs_map_string_to_job_status("SUCCEEDED"));
+        CHECK_EQUAL_C_INT((int)JOB_EXECUTION_CANCELED, (int)aws_iot_jobs_map_string_to_job_status("CANCELED"));
+        CHECK_EQUAL_C_INT((int)JOB_EXECUTION_REJECTED, (int)aws_iot_jobs_map_string_to_job_status("REJECTED"));
+        CHECK_EQUAL_C_INT((int)JOB_EXECUTION_UNKNOWN_STATUS, (int)aws_iot_jobs_map_string_to_job_status("invalidStatus"));
+
+        IOT_DEBUG("-->Success - string to status \n");
+}
+
+TEST_C(JobsTypesTests, StatusToString) {
+        IOT_DEBUG("\n-->Running Jobs Types Tests - status to string \n");
+
+        CHECK_EQUAL_C_STRING("QUEUED", aws_iot_jobs_map_status_to_string(JOB_EXECUTION_QUEUED));
+        CHECK_EQUAL_C_STRING("IN_PROGRESS", aws_iot_jobs_map_status_to_string(JOB_EXECUTION_IN_PROGRESS));
+        CHECK_EQUAL_C_STRING("FAILED", aws_iot_jobs_map_status_to_string(JOB_EXECUTION_FAILED));
+        CHECK_EQUAL_C_STRING("SUCCEEDED", aws_iot_jobs_map_status_to_string(JOB_EXECUTION_SUCCEEDED));
+        CHECK_EQUAL_C_STRING("CANCELED", aws_iot_jobs_map_status_to_string(JOB_EXECUTION_CANCELED));
+        CHECK_EQUAL_C_STRING("REJECTED", aws_iot_jobs_map_status_to_string(JOB_EXECUTION_REJECTED));
+        CHECK_EQUAL_C_STRING(NULL, aws_iot_jobs_map_status_to_string(JOB_EXECUTION_STATUS_NOT_SET));
+        CHECK_EQUAL_C_STRING(NULL, aws_iot_jobs_map_status_to_string(JOB_EXECUTION_UNKNOWN_STATUS));
+
+        IOT_DEBUG("-->Success - status to string \n");
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/tests/unit/src/aws_iot_tests_unit_shadow_action_helper.c b/tests/unit/src/aws_iot_tests_unit_shadow_action_helper.c
index 59bb3c8..684603d 100644
--- a/tests/unit/src/aws_iot_tests_unit_shadow_action_helper.c
+++ b/tests/unit/src/aws_iot_tests_unit_shadow_action_helper.c
@@ -759,12 +759,12 @@ TEST_C(ShadowActionTests, ACKWaitingMoreThanAllowed) {
         IOT_DEBUG("-->Success - Ack waiting more than allowed wait time \n");
 }
 
-#define JSON_SIZE_OVERFLOW "{\"state\":{\"reported\":{\"file\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}}, \"clientToken\":\"" AWS_IOT_MQTT_CLIENT_ID "-0\"}"
-
 TEST_C(ShadowActionTests, InboundDataTooBigForBuffer) {
+        uint32_t i = 0;
         IoT_Error_t ret_val = SUCCESS;
         char getRequestJson[120];
         IoT_Publish_Message_Params params;
+        char expectedCallbackString[AWS_IOT_MQTT_RX_BUF_LEN + 2];
 
         IOT_DEBUG("-->Running Shadow Action Tests - Inbound data too big for buffer \n");
 
@@ -775,8 +775,13 @@ TEST_C(ShadowActionTests, InboundDataTooBigForBuffer) {
                                                                                          false);
         CHECK_EQUAL_C_INT(SUCCESS, ret_val);
 
-        params.payloadLen = strlen(JSON_SIZE_OVERFLOW);
-        params.payload = JSON_SIZE_OVERFLOW;
+        for(i = 0; i < AWS_IOT_MQTT_RX_BUF_LEN; i++) {
+                expectedCallbackString[i] = 'X';
+        }
+        expectedCallbackString[i + 1] = '\0';
+
+        params.payloadLen = strlen(expectedCallbackString);
+        params.payload = expectedCallbackString;
         params.qos = QOS0;
         setTLSRxBufferWithMsgOnSubscribedTopic(GET_ACCEPTED_TOPIC, strlen(GET_ACCEPTED_TOPIC), QOS0, params,
                                                                                    params.payload);
diff --git a/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls.c b/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls.c
index f9a6cc7..950b5a1 100644
--- a/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls.c
+++ b/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls.c
@@ -72,10 +72,45 @@ IoT_Error_t iot_tls_is_connected(Network *pNetwork) {
         return NETWORK_PHYSICAL_LAYER_CONNECTED;
 }
 
+static size_t iot_tls_mqtt_read_variable_length_int(const unsigned char *buffer, size_t startPos) {
+        size_t result = 0;
+        size_t pos = startPos;
+        size_t multiplier = 1;
+        do {
+                result = (buffer[pos] & 0x7f) * multiplier;
+                multiplier *= 0x80;
+                pos++;
+        } while ((buffer[pos - 1] & 0x80) && pos - startPos < 4);
+
+        return result;
+}
+
+static size_t iot_tls_mqtt_get_end_of_variable_length_int(const unsigned char *buffer, size_t startPos) {
+        size_t pos = startPos;
+        while ((buffer[pos] & 0x80) && pos - startPos < 3) pos++;
+        pos++;
+
+        return pos;
+}
+
+static uint16_t iot_tls_mqtt_get_fixed_uint16_from_message(const unsigned char *msgBuffer, size_t startPos) {
+        uint8_t firstByte = (uint8_t)(msgBuffer[startPos]);
+        uint8_t secondByte = (uint8_t)(msgBuffer[startPos + 1]);
+        return (uint16_t) (secondByte + (256 * firstByte));
+}
+
+static uint16_t iot_tls_mqtt_copy_string_from_message(char *dest, const unsigned char *msgBuffer, size_t startPos) {
+        uint16_t length = iot_tls_mqtt_get_fixed_uint16_from_message(msgBuffer, startPos);
+
+        snprintf(dest, length + 1u, "%s", &(msgBuffer[startPos + 2])); // Added one for null character
+        return length;
+}
+
 IoT_Error_t iot_tls_write(Network *pNetwork, unsigned char *pMsg, size_t len, Timer *timer, size_t *written_len) {
         size_t i = 0;
-        uint8_t firstByte, secondByte;
-        uint16_t topicNameLen;
+        uint8_t firstPacketByte;
+        size_t mqttPacketLength;
+        size_t variableHeaderStart;
         IOT_UNUSED(pNetwork);
         IOT_UNUSED(timer);
 
@@ -85,17 +120,35 @@ IoT_Error_t iot_tls_write(Network *pNetwork, unsigned char *pMsg, size_t len, Ti
         TxBuffer.len = len;
         *written_len = len;
 
+        mqttPacketLength = iot_tls_mqtt_read_variable_length_int(TxBuffer.pBuffer, 1);
+        variableHeaderStart = iot_tls_mqtt_get_end_of_variable_length_int(TxBuffer.pBuffer, 1);
+
+        firstPacketByte = TxBuffer.pBuffer[0];
         /* Save last two subscribed topics */
-        if((TxBuffer.pBuffer[0] == 0x82 ? true : false)) {
-                snprintf(SecondLastSubscribeMessage, lastSubscribeMsgLen, "%s", LastSubscribeMessage);
+        if((firstPacketByte == 0x82 ? true : false)) {
+                snprintf(SecondLastSubscribeMessage, lastSubscribeMsgLen + 1u, "%s", LastSubscribeMessage);
                 secondLastSubscribeMsgLen = lastSubscribeMsgLen;
 
-                firstByte = (uint8_t)(TxBuffer.pBuffer[4]);
-                secondByte = (uint8_t)(TxBuffer.pBuffer[5]);
-                topicNameLen = (uint16_t) (secondByte + (256 * firstByte));
+                lastSubscribeMsgLen = iot_tls_mqtt_copy_string_from_message(
+                                LastSubscribeMessage, TxBuffer.pBuffer, variableHeaderStart + 2);
+        } else if (firstPacketByte == 0xA2) {
+                lastUnsubscribeMsgLen = iot_tls_mqtt_copy_string_from_message(
+                                                LastUnsubscribeMessage, TxBuffer.pBuffer, variableHeaderStart + 2);
+        } else if ((firstPacketByte & 0x30) == 0x30) {
+                QoS qos = (QoS) (firstPacketByte & 0x6 >> 1);
+
+                lastPublishMessageTopicLen =
+                                iot_tls_mqtt_copy_string_from_message(LastPublishMessageTopic, TxBuffer.pBuffer, variableHeaderStart);
+
+                size_t payloadStart = variableHeaderStart + 2 + lastPublishMessageTopicLen;
+
+                if (qos > QOS0) {
+                        payloadStart += 2;
+                }
 
-                snprintf(LastSubscribeMessage, topicNameLen + 1u, "%s", &(TxBuffer.pBuffer[6])); // Added one for null character
-                lastSubscribeMsgLen = topicNameLen + 1u;
+                lastPublishMessagePayloadLen = mqttPacketLength - payloadStart + 2; /* + 2 as the first two bytes don't count towards the length */
+                memcpy(LastPublishMessagePayload, TxBuffer.pBuffer + payloadStart, lastPublishMessagePayloadLen);
+                LastPublishMessagePayload[lastPublishMessagePayloadLen] = 0;
         }
 
         return SUCCESS;
diff --git a/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls_params.c b/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls_params.c
index efe8550..7523cdc 100644
--- a/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls_params.c
+++ b/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls_params.c
@@ -27,6 +27,14 @@ size_t lastSubscribeMsgLen;
 char SecondLastSubscribeMessage[TLSMaxBufferSize];
 size_t secondLastSubscribeMsgLen;
 
+char LastUnsubscribeMessage[TLSMaxBufferSize];
+size_t lastUnsubscribeMsgLen;
+
+char LastPublishMessageTopic[TLSMaxBufferSize];
+size_t lastPublishMessageTopicLen;
+char LastPublishMessagePayload[TLSMaxBufferSize];
+size_t lastPublishMessagePayloadLen;
+
 TlsBuffer RxBuffer = {.pBuffer = RxBuf,.len = 512, .NoMsgFlag=1, .expiry_time = {0, 0}, .BufMaxSize = TLSMaxBufferSize};
 TlsBuffer TxBuffer = {.pBuffer = TxBuf,.len = 512, .NoMsgFlag=1, .expiry_time = {0, 0}, .BufMaxSize = TLSMaxBufferSize};
 
diff --git a/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls_params.h b/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls_params.h
index 22a9ead..cfaad23 100644
--- a/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls_params.h
+++ b/tests/unit/tls_mock/aws_iot_tests_unit_mock_tls_params.h
@@ -25,8 +25,9 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
+#include <aws_iot_mqtt_client.h>
 
-#define TLSMaxBufferSize 1024
+#define TLSMaxBufferSize 2560
 #define NO_MSG_LENGTH_MENTIONED -1
 
 typedef struct {
@@ -49,6 +50,14 @@ extern size_t lastSubscribeMsgLen;
 extern char SecondLastSubscribeMessage[TLSMaxBufferSize];
 extern size_t secondLastSubscribeMsgLen;
 
+extern char LastUnsubscribeMessage[TLSMaxBufferSize];
+extern size_t lastUnsubscribeMsgLen;
+
+extern char LastPublishMessageTopic[TLSMaxBufferSize];
+extern size_t lastPublishMessageTopicLen;
+extern char LastPublishMessagePayload[TLSMaxBufferSize];
+extern size_t lastPublishMessagePayloadLen;
+
 extern char hostAddress[512];
 extern uint16_t port;
 extern uint32_t handshakeTimeout_ms;