diff --git a/index.js b/index.js
index 8358dad..f754a92 100644
--- a/index.js
+++ b/index.js
@@ -40,10 +40,12 @@ SQS.prototype.createQueue = function ( params, callback ) {
         MaximumMessageSize: 262144,
         MessageRetentionPeriod: 345600,
         ReceiveMessageWaitTimeSeconds: 0,
-        VisibilityTimeout: 30
+        VisibilityTimeout: 30,
+        CreatedTimestamp: new Date().getTime()
     }, params.Attributes );
 
     queues[ qurl ] = {
+        name: qname,
         attributes: attributes,
         messages: []
     }
@@ -55,6 +57,50 @@ SQS.prototype.createQueue = function ( params, callback ) {
     })
 }
 
+SQS.prototype.getQueueAttributes = function ( params, callback ) {
+    callback = callback || function () {}
+    params = extend( {}, this.params, params );
+
+    var qurl = params.QueueUrl;
+    if ( !qurl ) {
+        callback( new Error( 'QueueUrl is required' ) )
+        return
+    }
+
+    var queue = queues[ qurl ];
+    if ( !queue ) {
+        callback( new Error( 'Queue doesn\'t exist for Url:' + qurl ) );
+        return;
+    }
+
+    // add the approximations
+    var now = new Date().getTime();
+    var visible = queue.messages.filter( function ( message ) {
+        return !message._inflight
+            || message._inflight <= now;
+    }).length;
+    var invisible = queue.messages.length - visible;
+    queue.attributes.ApproximateNumberOfMessages = visible;
+    queue.attributes.ApproximateNumberOfMessagesNotVisible = invisible;
+
+    var names = params.AttributeNames || [ 'All' ];
+
+    var attributes = Object.keys( queue.attributes )
+        .filter( function ( key ) {
+            return names.indexOf( 'All' ) !== -1
+                || names.indexOf( key ) !== -1
+        })
+        .reduce( function ( attributes, key ) {
+            attributes[ key ] = queue.attributes[ key ]
+            return attributes
+        }, {} );
+
+    setTimeout( function () {
+        callback( null, { Attributes: attributes } )
+    })
+
+}
+
 SQS.prototype.deleteQueue = function ( params, callback ) {
     callback = callback || function () {}
     params = extend( {}, this.params, params );
@@ -74,7 +120,8 @@ SQS.prototype.listQueues = function ( params, callback ) {
     var prefix = params.QueueNamePrefix || '';
     var urls = Object.keys( queues )
         .filter( function ( qurl ) {
-            return qurl.indexOf( prefix ) === 0;
+            var name = queues[ qurl ].name;
+            return name.indexOf( prefix ) === 0;
         })
 
     setTimeout( function () {
@@ -138,7 +185,7 @@ SQS.prototype.sendMessage = function ( params, callback ) {
     queue.messages.push({
         MessageId: messageId,
         Body: body,
-        MessageAttributes: extend( {}, params.MessageAttributes ) // copy
+        MessageAttributes: extend( {}, params.MessageAttributes ), // copy
         Attributes: attributes
     })
 
@@ -164,15 +211,31 @@ SQS.prototype.receiveMessage = function ( params, callback ) {
         return;
     }
 
-    var max = params.MaxNumberOfMessages || 1;
+    var max = params.MaxNumberOfMessages === undefined
+        ? 1
+        : params.MaxNumberOfMessages;
+
     if ( max > 10 || max < 1 ) {
         callback( new Error( 'MaxNumberOfMessages out of range' ) );
         return;
     }
 
+    var vis = params.VisibilityTimeout === undefined
+        ? queue.attributes.VisibilityTimeout
+        : params.VisibilityTimeout;
+
+    var now = new Date().getTime();
+    var inflight = now + ( vis * 1000 );
+
     var messages = queue.messages;
-    var received = messages.slice( 0, max )
+    var received = messages
+        .filter( function ( message ) {
+            return !message._inflight
+                || message._inflight <= now;
+        })
+        .slice( 0, max )
         .map( function ( message ) {
+            message._inflight = inflight;
             message.ReceiptHandle = uuid.v4()
             message.Attributes.ApproximateReceiveCount += 1;
             if ( !message.Attributes.ApproximateFirstReceiveTimestamp ) {
@@ -180,6 +243,8 @@ SQS.prototype.receiveMessage = function ( params, callback ) {
                 message.Attributes.ApproximateFirstReceiveTimestamp = timestamp;
             }
 
+            message = extend( {}, message );
+            delete message._inflight;
             return message;
         });
 
@@ -211,9 +276,11 @@ SQS.prototype.deleteMessage = function ( params, callback ) {
         return;
     }
 
-    queue.messages = queue.messages.filter( function ( message ) {
-        return message.ReceiptHandle !== receipt;
+    var message = queue.messages.filter( function ( message ) {
+        return message.ReceiptHandle === receipt;
     })
+    var idx = queue.messages.indexOf( message );
+    queue.messages.splice( idx, 1 );
 
     setTimeout( function () {
         callback( null, {} )
diff --git a/package.json b/package.json
index b0e095d..04df713 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "mock-sqs",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Mocking library for Amazon's SQS Node.js SDK",
   "main": "index.js",
   "scripts": {
diff --git a/test.js b/test.js
new file mode 100644
index 0000000..290c20e
--- /dev/null
+++ b/test.js
@@ -0,0 +1,846 @@
+var assert = require( 'assert' );
+var Promise = require( 'bluebird' );
+
+var mocksqs = require( './index' );
+
+afterEach( function () {
+    mocksqs.reset();
+})
+
+describe( '.createQueue', function () {
+
+    it( 'sets the queue name and region', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS({
+            region: 'hello'
+        }) );
+        sqs.createQueueAsync({
+            QueueName: 'q1'
+        })
+        .then( function ( res ) {
+            assert( res.QueueUrl );
+            assert.equal( res.QueueUrl.split( '.' )[ 1 ], 'hello' );
+            assert.equal( res.QueueUrl.split( '/' ).pop(), 'q1' )
+            done();
+        })
+        .catch( done );
+    })
+
+    it( 'fails when queue name is missing', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.createQueueAsync({})
+            .then( function () {
+                done( 'Error expected for required QueueName' )
+            })
+            .catch( function ( err ) {
+                assert( err.toString().match( /QueueName.*required/ig ) )
+                done();
+            })
+    })
+
+    it( 'fails when queue name already exists', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.createQueueAsync({
+            QueueName: 'q1'
+        })
+        .then( function () {
+            return sqs.createQueueAsync({
+                QueueName: 'q1'
+            })
+        })
+        .then( function () {
+            done( 'Error expected for Queue already exists' );
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /Queue.*q1.*already exists/ig ) );
+            done();
+        })
+    })
+
+    it( 'overwrites the default attributes', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.createQueueAsync({
+            QueueName: 'q1',
+            Attributes: {
+                DelaySeconds: 30,
+                MaximumMessageSize: 1024,
+                MessageRetentionPeriod: 120,
+                ReceiveMessageWaitTimeSeconds: 3,
+                VisibilityTimeout: 45
+            }
+        })
+        .then( function ( res ) {
+            return sqs.getQueueAttributesAsync({
+                QueueUrl: res.QueueUrl,
+                AttributeNames: [ 'All' ]
+            })
+        })
+        .then( function ( res ) {
+            var attribs = res.Attributes;
+            assert.equal( attribs.DelaySeconds, 30 );
+            assert.equal( attribs.MaximumMessageSize, 1024 );
+            assert.equal( attribs.MessageRetentionPeriod, 120 );
+            assert.equal( attribs.ReceiveMessageWaitTimeSeconds, 3 );
+            assert.equal( attribs.VisibilityTimeout, 45 );
+
+            done();
+        })
+        .catch( done )
+    })
+
+})
+
+describe( '.getQueueAttributes', function () {
+
+    var qurl;
+    beforeEach( function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.createQueueAsync({
+            QueueName: 'q1',
+        })
+        .then( function ( res ) {
+            qurl = res.QueueUrl
+            done();
+        })
+        .catch( done )
+    })
+
+    it( 'returns specific attributes', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        return sqs.getQueueAttributesAsync({
+            QueueUrl: qurl,
+            AttributeNames: [ 'CreatedTimestamp', 'DelaySeconds' ]
+        })
+        .then( function ( res ) {
+            var attribs = res.Attributes;
+            assert.equal( Object.keys( attribs ).length, 2 );
+            assert.notEqual( attribs.DelaySeconds, undefined );
+            assert.equal( typeof attribs.CreatedTimestamp, 'number' );
+            done();
+        })
+        .catch( done )
+    })
+
+    it( 'returns count approximations', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        return sqs.sendMessageAsync({
+            QueueUrl: qurl,
+            MessageBody: 'hello world'
+        })
+        .then( function () {
+            return sqs.sendMessageAsync({
+                QueueUrl: qurl,
+                MessageBody: 'foo bar'
+            })
+        })
+        .then( function () {
+            return sqs.receiveMessage({
+                QueueUrl: qurl
+            })
+        })
+        .then( function () {
+            return sqs.getQueueAttributesAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            var attribs = res.Attributes;
+            assert.equal( attribs.ApproximateNumberOfMessages, 1 );
+            assert.equal( attribs.ApproximateNumberOfMessagesNotVisible, 1 );
+            done();
+        })
+        .catch( done )
+    })
+
+    it( 'fails when queue url is missing', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.getQueueAttributesAsync({})
+            .then( function () {
+                done( 'Error expected for required QueueUrl' )
+            })
+            .catch( function ( err ) {
+                assert( err.toString().match( /QueueUrl.*required/ig ) )
+                done();
+            })
+    })
+
+    it( 'fails when queue doesn\'t exists', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.getQueueAttributesAsync({
+            QueueUrl: 'hello'
+        })
+        .then( function () {
+            done( 'Error expected for Queue doesn\'t exists' );
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /Queue.*doesn\'t exist.*hello/ig ) );
+            done();
+        })
+    })
+
+})
+
+describe( '.listQueues', function () {
+
+    var qurl1;
+    var qurl2;
+    beforeEach( function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.createQueueAsync({
+            QueueName: 'q1-hello'
+        })
+        .then( function ( res ) {
+            qurl1 = res.QueueUrl
+            return sqs.createQueueAsync({
+                QueueName: 'q2-world'
+            })
+        })
+        .then( function ( res ) {
+            qurl2 = res.QueueUrl;
+            done();
+        })
+        .catch( done )
+    });
+
+    it( 'lists all of the queues', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.listQueuesAsync({})
+            .then( function ( res ) {
+                assert.equal( res.QueueUrls.length, 2 );
+                assert.equal( res.QueueUrls[ 0 ], qurl1 );
+                assert.equal( res.QueueUrls[ 1 ], qurl2 );
+                done();
+            })
+            .catch( done );
+    })
+
+    it( 'search by prefix', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.listQueuesAsync({
+            QueueNamePrefix: 'q2-'
+        })
+        .then( function ( res ) {
+            assert.equal( res.QueueUrls.length, 1 );
+            assert.equal( res.QueueUrls[ 0 ], qurl2 );
+            done();
+        })
+        .catch( done );
+    })
+
+})
+
+describe( '.deleteQueue', function () {
+
+    var qurl;
+    beforeEach( function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.createQueueAsync({
+            QueueName: 'q1'
+        })
+        .then( function ( res ) {
+            qurl = res.QueueUrl
+            done();
+        })
+        .catch( done )
+    })
+
+    it( 'deletes the queue', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.deleteQueueAsync({
+            QueueUrl: qurl
+        })
+        .then( function () {
+            return sqs.listQueuesAsync({})
+        })
+        .then( function ( res ) {
+            assert.equal( res.QueueUrls.length, 0 )
+            done();
+        })
+        .catch( done )
+    });
+
+    it( 'quietly ignores missing queues', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.deleteQueueAsync({
+            QueueUrl: 'hello'
+        })
+        .then( function () {
+            return sqs.listQueuesAsync({})
+        })
+        .then( function ( res ) {
+            assert.equal( res.QueueUrls.length, 1 )
+            assert.equal( res.QueueUrls[ 0 ], qurl );
+            done();
+        })
+        .catch( done )
+    })
+})
+
+describe( '.sendMessage', function () {
+
+    var qurl;
+    beforeEach( function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.createQueueAsync({
+            QueueName: 'q1'
+        })
+        .then( function ( res ) {
+            qurl = res.QueueUrl
+            done();
+        })
+        .catch( done )
+    })
+
+    it( 'generates unique message ids', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        var messageId;
+        sqs.sendMessageAsync({
+            QueueUrl: qurl,
+            MessageBody: 'hello world'
+        })
+        .then( function ( res ) {
+            messageId = res.MessageId;
+            assert( messageId );
+            return sqs.sendMessageAsync({
+                QueueUrl: qurl,
+                MessageBody: 'foo bar'
+            })
+        })
+        .then( function ( res ) {
+            assert.notEqual( res.MessageId, messageId );
+            done();
+        })
+        .catch( done );
+    })
+
+    it( 'fails when queue url is missing', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.sendMessageAsync({
+            MessageBody: 'hello world'
+        })
+        .then( function () {
+            done( 'Error expected for required QueueUrl' )
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /QueueUrl.*required/ig ) )
+            done();
+        })
+    })
+
+    it( 'fails when message body is missing', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.sendMessageAsync({
+            QueueUrl: qurl
+        })
+        .then( function () {
+            done( 'Error expected for required MessageBody' )
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /MessageBody.*required/ig ) )
+            done();
+        })
+    })
+
+    it( 'fails when queue doesn\'t exists', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.sendMessageAsync({
+            QueueUrl: 'hello',
+            MessageBody: 'hello world'
+        })
+        .then( function () {
+            done( 'Error expected for Queue doesn\'t exists' );
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /Queue.*doesn\'t exist.*hello/ig ) );
+            done();
+        })
+    })
+
+    it( 'stores the message body', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.sendMessageAsync({
+            QueueUrl: qurl,
+            MessageBody: 'hello world'
+        })
+        .then( function () {
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            var body = res.Messages[ 0 ].Body;
+            assert.equal( body, 'hello world' );
+            done();
+        })
+        .catch( done )
+    })
+
+    it( 'stores the SentTime', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        var before = new Date().getTime();
+        sqs.sendMessageAsync({
+            QueueUrl: qurl,
+            MessageBody: 'hello world'
+        })
+        .then( function () {
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            var attribs = res.Messages[ 0 ].Attributes;
+
+            var after = new Date().getTime();
+            assert( attribs.SentTimestamp >= before );
+            assert( attribs.SentTimestamp <= after );
+            done();
+        })
+        .catch( done )
+    })
+
+    it( 'stores the message attributes', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.sendMessageAsync({
+            QueueUrl: qurl,
+            MessageBody: 'hello world',
+            MessageAttributes: {
+                foo: {
+                    DataType: 'String',
+                    StringValue: 'bar'
+                }
+            }
+        })
+        .then( function () {
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            var attribs = res.Messages[ 0 ].MessageAttributes;
+            assert.deepEqual( attribs, {
+                foo: {
+                    DataType: 'String',
+                    StringValue: 'bar'
+                }
+            })
+            
+            done();
+        })
+        .catch( done )
+    })
+})
+
+describe( '.receiveMessage', function () {
+
+    var qurl;
+    var messageId;
+    beforeEach( function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.createQueueAsync({
+            QueueName: 'q1',
+            Attributes: {
+                VisibilityTimeout: 0
+            }
+        })
+        .then( function ( res ) {
+            qurl = res.QueueUrl
+            return sqs.sendMessageAsync({
+                QueueUrl: qurl,
+                MessageBody: 'hello world',
+            })
+        })
+        .then( function ( res ) {
+            messageId = res.MessageId;
+            done();
+        })
+        .catch( done )
+    })
+
+    it( 'receives the correct message id', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.receiveMessageAsync({
+            QueueUrl: qurl
+        })
+        .then( function ( res ) {
+            assert.equal( res.Messages.length, 1 );
+            assert.equal( res.Messages[ 0 ].MessageId, messageId );
+            done();
+        })
+        .catch( done );
+    })
+
+    it( 'recieves a different receipt handle for each time', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        var receipt;
+        sqs.receiveMessageAsync({
+            QueueUrl: qurl
+        })
+        .then( function ( res ) {
+            receipt = res.Messages[ 0 ].ReceiptHandle;
+            assert( receipt );
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            assert.notEqual( res.Messages[ 0 ].ReceiptHandle, receipt );
+            done();
+        })
+        .catch( done );
+    })
+
+    it( 'increments the receive count', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.receiveMessageAsync({
+            QueueUrl: qurl
+        })
+        .then( function ( res ) {
+            var attribs = res.Messages[ 0 ].Attributes;
+            assert.equal( attribs.ApproximateReceiveCount, 1 )
+
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            var attribs = res.Messages[ 0 ].Attributes;
+            assert.equal( attribs.ApproximateReceiveCount, 2 )
+            done();
+        })
+        .catch( done );
+    })
+
+    it( 'stores the first receive time', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        var before = new Date().getTime();
+        var first;
+        sqs.receiveMessageAsync({
+            QueueUrl: qurl
+        })
+        .then( function ( res ) {
+            var attribs = res.Messages[ 0 ].Attributes;
+            first = attribs.ApproximateFirstReceiveTimestamp;
+            assert( first >= before );
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            var attribs = res.Messages[ 0 ].Attributes;
+            assert.equal( attribs.ApproximateFirstReceiveTimestamp, first )
+            done();
+        })
+        .catch( done );
+    })
+
+    it( 'fails when queue url is missing', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.receiveMessageAsync({})
+            .then( function () {
+                done( 'Error expected for required QueueUrl' )
+            })
+            .catch( function ( err ) {
+                assert( err.toString().match( /QueueUrl.*required/ig ) )
+                done();
+            })
+    })
+
+    it( 'fails when queue doesn\'t exists', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.receiveMessageAsync({
+            QueueUrl: 'hello',
+        })
+        .then( function () {
+            done( 'Error expected for Queue doesn\'t exists' );
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /Queue.*doesn\'t exist.*hello/ig ) );
+            done();
+        })
+    })
+
+    it( 'fails when MaxMessages is out of range', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.receiveMessageAsync({
+            QueueUrl: qurl,
+            MaxNumberOfMessages: 11
+        })
+        .then( function () {
+            done( 'Error expected for MaxMessages out of range' );
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /MaxNumberOfMessages.*out of range/ig ) );
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl,
+                MaxNumberOfMessages: 0
+            })
+        })
+        .then( function () {
+            done( 'Error expected for MaxMessages out of range' );
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /MaxNumberOfMessages.*out of range/ig ) );
+            done();
+        });
+
+    })
+
+    it( 'receives a single message by default', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        var messageId2;
+        return sqs.sendMessageAsync({
+            QueueUrl: qurl,
+            MessageBody: 'foo bar',
+        })
+        .then( function ( res ) {
+            messageId2 = res.MessageId;
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            assert.equal( res.Messages.length, 1 );
+
+            var msg = res.Messages[ 0 ];
+            var ids = [ messageId, messageId2 ];
+            assert.notEqual( ids.indexOf( msg.MessageId ), -1 )
+            done();
+        })
+    })
+
+    it( 'receives multiple messages', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        var messageId2;
+        return sqs.sendMessageAsync({
+            QueueUrl: qurl,
+            MessageBody: 'foo bar',
+        })
+        .then( function ( res ) {
+            messageId2 = res.MessageId;
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl,
+                MaxNumberOfMessages: 5
+            })
+        })
+        .then( function ( res ) {
+            assert.equal( res.Messages.length, 2 );
+            done();
+        })
+    });
+
+    it( 'hides received messages', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        return sqs.receiveMessageAsync({
+            QueueUrl: qurl,
+            VisibilityTimeout: .02
+        })
+        .then( function ( res ) {
+            assert.equal( res.Messages.length, 1 );
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl,
+            })
+        })
+        .then( function ( res ) {
+            assert.equal( res.Messages.length, 0 );
+        })
+        .delay( 30 )
+        .then( function () {
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl,
+            })
+        })
+        .then( function ( res ) {
+            assert.equal( res.Messages.length, 1 );
+            done();
+        })
+        .catch( done );
+    })
+
+})
+
+describe( '.deleteMessage', function () {
+
+    var qurl;
+    var receipt;
+    beforeEach( function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.createQueueAsync({
+            QueueName: 'q1',
+            Attributes: {
+                VisibilityTimeout: 0
+            }
+        })
+        .then( function ( res ) {
+            qurl = res.QueueUrl
+            return sqs.sendMessageAsync({
+                QueueUrl: qurl,
+                MessageBody: 'hello world',
+            })
+        })
+        .then( function () {
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            receipt = res.Messages[ 0 ].ReceiptHandle;
+            done();
+        })
+        .catch( done )
+    })
+
+    it( 'deletes a message', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        return sqs.deleteMessageAsync({
+            QueueUrl: qurl,
+            ReceiptHandle: receipt
+        })
+        .then( function () {
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            assert.equal( res.Messages.length, 0 );
+            done();
+        })
+        .catch( done );
+    })
+
+    it( 'quietly ignores missing receipts', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        return sqs.deleteMessageAsync({
+            QueueUrl: qurl,
+            ReceiptHandle: 'hello'
+        })
+        .then( function () {
+            done();
+        })
+        .catch( done );
+    })
+
+    it( 'fails when queue url is missing', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.deleteMessageAsync({
+            ReceiptHandle: receipt
+        })
+        .then( function () {
+            done( 'Error expected for required QueueUrl' )
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /QueueUrl.*required/ig ) )
+            done();
+        })
+    })
+
+    it( 'fails when receipt handle is missing', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.deleteMessageAsync({
+            QueueUrl: qurl,
+        })
+        .then( function () {
+            done( 'Error expected for required ReceiptHandle' )
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /ReceiptHandle.*required/ig ) )
+            done();
+        })
+    })
+
+    it( 'fails when queue doesn\'t exists', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.deleteMessageAsync({
+            QueueUrl: 'hello',
+            ReceiptHandle: receipt
+        })
+        .then( function () {
+            done( 'Error expected for Queue doesn\'t exists' );
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /Queue.*doesn\'t exist.*hello/ig ) );
+            done();
+        })
+    })
+})
+
+describe( '.purgeQueue', function () {
+
+    var qurl;
+    var receipt;
+    beforeEach( function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.createQueueAsync({
+            QueueName: 'q1',
+            Attributes: {
+                VisibilityTimeout: 0
+            }
+        })
+        .then( function ( res ) {
+            qurl = res.QueueUrl
+            return sqs.sendMessageAsync({
+                QueueUrl: qurl,
+                MessageBody: 'hello world',
+            })
+        })
+        .then( function () {
+            done();
+        })
+        .catch( done )
+    });
+
+    it( 'removes all messages in the queue', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.purgeQueueAsync({
+            QueueUrl: qurl
+        })
+        .then( function () {
+            return sqs.receiveMessageAsync({
+                QueueUrl: qurl
+            })
+        })
+        .then( function ( res ) {
+            assert.equal( res.Messages.length, 0 );
+            done();
+        })
+        .catch( done );
+    })
+
+    it( 'fails when queue url is missing', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.purgeQueueAsync({})
+            .then( function () {
+                done( 'Error expected for required QueueUrl' )
+            })
+            .catch( function ( err ) {
+                assert( err.toString().match( /QueueUrl.*required/ig ) )
+                done();
+            })
+    })
+
+    it( 'fails when queue doesn\'t exists', function ( done ) {
+        var sqs = Promise.promisifyAll( new mocksqs.SQS() );
+        sqs.purgeQueueAsync({
+            QueueUrl: 'hello',
+        })
+        .then( function () {
+            done( 'Error expected for Queue doesn\'t exists' );
+        })
+        .catch( function ( err ) {
+            assert( err.toString().match( /Queue.*doesn\'t exist.*hello/ig ) );
+            done();
+        })
+    })
+
+})
+
+
+
+
+
+
+
+
+
+
+
+
+