diff --git a/amqp_core/src/error.rs b/amqp_core/src/error.rs
index 2d2f3b8..9f7f8e5 100644
--- a/amqp_core/src/error.rs
+++ b/amqp_core/src/error.rs
@@ -16,48 +16,105 @@ pub enum ProtocolError {
 
 #[derive(Debug, thiserror::Error)]
 pub enum ConException {
+    #[error("320 Connection forced")]
+    ConnectionForced,
+    #[error("402 Invalid path")]
+    InvalidPath,
     #[error("501 Frame error")]
     FrameError,
-    #[error("503 Command invalid")]
-    CommandInvalid,
-    #[error("503 Syntax error | {0:?}")]
+    #[error("502 Syntax error | {0:?}")]
     /// A method was received but there was a syntax error. The string stores where it occurred.
     SyntaxError(Vec<String>),
+    #[error("503 Command invalid")]
+    CommandInvalid,
     #[error("504 Channel error")]
     ChannelError,
     #[error("505 Unexpected Frame")]
     UnexpectedFrame,
+    #[error("506 Resource Error")]
+    ResourceError,
+    #[error("530 Not allowed")]
+    NotAllowed,
     #[error("540 Not implemented. '{0}'")]
     NotImplemented(&'static str),
-    #[error("xxx Not decided yet")]
+    #[error("541 Internal error")]
+    InternalError,
+    #[error("xxx Todo")]
     Todo,
 }
 
 impl ConException {
     pub fn reply_code(&self) -> ReplyCode {
         match self {
+            ConException::ConnectionForced => 320,
+            ConException::InvalidPath => 402,
             ConException::FrameError => 501,
             ConException::CommandInvalid => 503,
             ConException::SyntaxError(_) => 503,
             ConException::ChannelError => 504,
             ConException::UnexpectedFrame => 505,
+            ConException::ResourceError => 506,
+            ConException::NotAllowed => 530,
+            ConException::InternalError => 541,
             ConException::NotImplemented(_) => 540,
             ConException::Todo => 0,
         }
     }
     pub fn reply_text(&self) -> ReplyText {
-        "cant be bothered yet".to_string() // todo
+        match self {
+            ConException::ConnectionForced => "connection-forced",
+            ConException::InvalidPath => "invalid-path",
+            ConException::FrameError => "frame-error",
+            ConException::SyntaxError(_) => "syntax-error",
+            ConException::CommandInvalid => "command-invalid",
+            ConException::ChannelError => "channel-error",
+            ConException::UnexpectedFrame => "unexpected-frame",
+            ConException::ResourceError => "resource-error",
+            ConException::NotAllowed => "not-allowed",
+            ConException::NotImplemented(_) => "not-implemented",
+            ConException::InternalError => "internal-error",
+            ConException::Todo => "todo",
+        }
+        .to_owned()
     }
 }
 
 #[derive(Debug, thiserror::Error)]
-pub enum ChannelException {}
+pub enum ChannelException {
+    #[error("311 Content too large")]
+    ContentTooLarge,
+    #[error("313 No consumers")]
+    NoConsumers,
+    #[error("403 Access refused")]
+    AccessRefused,
+    #[error("404 Not found")]
+    NotFound,
+    #[error("405 Resource locked")]
+    ResourceLocked,
+    #[error("406 Precondition failed")]
+    PreconditionFailed,
+}
 
 impl ChannelException {
     pub fn reply_code(&self) -> ReplyCode {
-        todo!()
+        match self {
+            ChannelException::ContentTooLarge => 311,
+            ChannelException::NoConsumers => 313,
+            ChannelException::AccessRefused => 403,
+            ChannelException::NotFound => 404,
+            ChannelException::ResourceLocked => 405,
+            ChannelException::PreconditionFailed => 406,
+        }
     }
     pub fn reply_text(&self) -> ReplyText {
-        todo!()
+        match self {
+            ChannelException::ContentTooLarge => "content-too-large",
+            ChannelException::NoConsumers => "no-consumers",
+            ChannelException::AccessRefused => "access-refused",
+            ChannelException::NotFound => "not-found",
+            ChannelException::ResourceLocked => "resource-locked",
+            ChannelException::PreconditionFailed => "precondition-failed",
+        }
+        .to_owned()
     }
 }
diff --git a/amqp_transport/src/connection.rs b/amqp_transport/src/connection.rs
index 14eb7c5..924e37e 100644
--- a/amqp_transport/src/connection.rs
+++ b/amqp_transport/src/connection.rs
@@ -102,7 +102,7 @@ impl Connection {
                 /* do nothing, remove below */
             }
             Err(TransError::Protocol(ProtocolError::ConException(ex))) => {
-                warn!(%ex, "Connection exception occured. This indicates a faulty client.");
+                warn!(%ex, "Connection exception occurred. This indicates a faulty client.");
                 if let Err(err) = self
                     .send_method(
                         ChannelNum::zero(),
@@ -262,6 +262,7 @@ impl Connection {
             match result {
                 Ok(()) => {}
                 Err(TransError::Protocol(ProtocolError::ChannelException(ex))) => {
+                    warn!(%ex, "Channel exception occurred");
                     self.send_method(
                         channel,
                         Method::ChannelClose(ChannelClose {
diff --git a/test-js/src/declare-queue.js b/test-js/src/declare-queue.js
index 9a5f979..b81d670 100644
--- a/test-js/src/declare-queue.js
+++ b/test-js/src/declare-queue.js
@@ -6,7 +6,7 @@ const connection = await connectAmqp();
 
 const channel = await connection.createChannel();
 
-const reply = await channel.assertQueue(queueName, { durable: true });
+const reply = await channel.assertQueue(queueName, { durable: false });
 
 assert(reply.messageCount === 0, 'Message found in queue');
 assert(reply.consumerCount === 0, 'Consumer listening on queue');