working on protocol unit tests

Author: sdether

Beanstalk.Client.IntegrationTest/BeanstalkClientTests.cs

@@ -34,8 +34,8 @@ public void Put_Reserve_Delete() {
                 var stream = data.AsStream();
                 var put = client.Put(100, TimeSpan.Zero, TimeSpan.FromMinutes(2), stream, data.Length);
                 var reserve = client.Reserve();
-                Assert.AreEqual(put.JobId, reserve.JobId);
-                Assert.IsTrue(client.Delete(reserve.JobId));
+                Assert.AreEqual(put.JobId, reserve.Id);
+                Assert.IsTrue(client.Delete(reserve.Id));
                 using(var reader = new StreamReader(reserve.Data)) {
                     Assert.AreEqual(data, reader.ReadToEnd());
                 }

Beanstalk.Client.Test/Beanstalk.Client.Test.csproj

@@ -57,8 +57,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="BeanstalkClientTests.cs" />
+    <Compile Include="BeanstalkProtocolTests.cs" />
     <Compile Include="ExtensionTests.cs" />
+    <Compile Include="MockSocket.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="RequestTests.cs" />
     <Compile Include="TestExtensions.cs" />

Beanstalk.Client.Test/BeanstalkClientTests.cs

@@ -0,0 +1,93 @@
+/*
+ * libBeanstalk.NET 
+ * Copyright (C) 2010 Arne F. Claassen
+ * geekblog [at] claassen [dot] net
+ * http://github.com/sdether/libBeanstalk.NET 
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ */
+
+using System;
+using NUnit.Framework;
+
+namespace Droog.Beanstalk.Client.Test {
+
+    [TestFixture]
+    public class BeanstalkProtocolTests {
+        private MockSocket _mockSocket;
+        private BeanstalkClient _client;
+        private int _socketCreated = 0;
+
+        [SetUp]
+        public void Setup() {
+            _socketCreated = 0;
+            _mockSocket = new MockSocket();
+            _client = new BeanstalkClient(() => {
+                _socketCreated++;
+                _mockSocket.Connected = true;
+                return _mockSocket;
+            });
+        }
+
+        [Test]
+        public void Can_connect_to_and_disconnect_from_server() {
+            _client.Connect();
+            Assert.AreEqual(1, _socketCreated);
+            _client.Close();
+            Assert.AreEqual(1, _mockSocket.CloseCalled);
+        }
+
+        [Test]
+        public void Dispose_disconnects_from_server() {
+            _client.Connect();
+            Assert.AreEqual(1, _socketCreated);
+            _client.Dispose();
+            Assert.AreEqual(1, _mockSocket.CloseCalled);
+        }
+
+        [Test]
+        public void Can_put_data() {
+            _mockSocket.Expect("put 123 0 60 3\r\nfoo\r\n", "INSERTED 456\r\n");
+            var data = "foo".AsStream();
+            var response = _client.Put(123, TimeSpan.Zero, TimeSpan.FromSeconds(60), data, data.Length);
+            _mockSocket.Verify();
+            Assert.AreEqual(456, response.JobId);
+        }
+
+        [Test]
+        public void Can_set_tube() {
+            _mockSocket.Expect("use bob\r\n", "USING bob\r\n");
+            _client.CurrentTube = "bob";
+            _mockSocket.Verify();
+            Assert.AreEqual("bob",_client.CurrentTube);
+        }
+
+        [Test]
+        public void Can_reserve_without_timeout() {
+            _mockSocket.Expect("reserve\r\n", "RESERVED 123 3\r\nbar\r\n");
+            var job = _client.Reserve();
+            _mockSocket.Verify();
+            Assert.AreEqual(123,job.Id);
+            Assert.AreEqual("bar",job.Data.AsText());
+        }
+
+        [Test]
+        public void Can_reserve_with_timeout() {
+            _mockSocket.Expect("reserve 10\r\n", "RESERVED 123 3\r\nbar\r\n");
+            var job = _client.Reserve(TimeSpan.FromSeconds(10));
+            _mockSocket.Verify();
+            Assert.AreEqual(123, job.Id);
+            Assert.AreEqual("bar", job.Data.AsText());
+        }
+    }
+}

Beanstalk.Client.Test/BeanstalkProtocolTests.cs

@@ -0,0 +1,38 @@
+using System;
+using System.IO;
+using Droog.Beanstalk.Client.Protocol;
+using NUnit.Framework;
+
+namespace Droog.Beanstalk.Client.Test {
+    public class MockSocket : ISocket {
+        public int CloseCalled;
+        private readonly MemoryStream _sentData = new MemoryStream();
+        private MemoryStream _receivedData = new MemoryStream();
+        private string _sent;
+
+        public void Close() {
+            CloseCalled++;
+            Connected = false;
+        }
+
+        public bool Connected { get; set; }
+
+        public int Send(byte[] buffer, int offset, int size) {
+            _sentData.Write(buffer, offset, size);
+            return size;
+        }
+
+        public int Receive(byte[] buffer, int offset, int size) {
+            return _receivedData.Read(buffer, offset, size);
+        }
+
+        public void Expect(string sent, string received) {
+            _receivedData = received.AsStream();
+            _sent = sent;
+        }
+
+        public void Verify() {
+            Assert.AreEqual(_sent, _sentData.AsText());
+        }
+    }
+}

Beanstalk.Client.Test/MockSocket.cs

@@ -34,5 +34,12 @@ public static string AsText(this RequestData data) {
             return Encoding.ASCII.GetString(buffer, 0, count);
         }
 
+        public static string AsText(this Stream stream) {
+            stream.Position = 0;
+            using(var reader = new StreamReader(stream)) {
+                return reader.ReadToEnd();
+            }
+        }
+
     }
 }

Beanstalk.Client.Test/TestExtensions.cs

@@ -247,9 +247,7 @@ public IEnumerable<string> GetTubes() {
         }
 
         public void Close() {
-            if(_isDisposed) {
-                throw new ObjectDisposedException(GetType().ToString());
-            }
+            ThrowIfDisposed();
             if(_socket == null || !_socket.Connected) {
                 return;
             }
@@ -290,9 +288,7 @@ private Response Exec(Request request) {
         }
 
         private void VerifyConnection() {
-            if(_isDisposed) {
-                throw new ObjectDisposedException(GetType().ToString());
-            }
+            ThrowIfDisposed();
             if(_socket != null && !_socket.Connected) {
                 _socket.Close();
                 _socket = null;
@@ -302,6 +298,12 @@ private void VerifyConnection() {
             }
         }
 
+        private void ThrowIfDisposed() {
+            if(_isDisposed) {
+                throw new ObjectDisposedException(GetType().ToString());
+            }
+        }
+
         public void Dispose() {
             Dispose(true);
         }

Beanstalk.Client/BeanstalkClient.cs

@@ -51,7 +51,7 @@ public static PutResponse Put(this IBeanstalkClient client, string data, uint pr
         public static Job<string> Reserve(this IBeanstalkClient client) {
             var job = client.Reserve();
             using(var reader = new StreamReader(job.Data)) {
-                return new Job<string>(job.JobId, reader.ReadToEnd());
+                return new Job<string>(job.Id, reader.ReadToEnd());
             }
         }
 
@@ -61,7 +61,7 @@ public static Job<string> Reserve(this IBeanstalkClient client, TimeSpan timeout
                 return null;
             }
             using(var reader = new StreamReader(job.Data)) {
-                return new Job<string>(job.JobId, reader.ReadToEnd());
+                return new Job<string>(job.Id, reader.ReadToEnd());
             }
         }
     }

Beanstalk.Client/BeanstalkExtensions.cs

@@ -22,17 +22,17 @@
 
 namespace Droog.Beanstalk.Client {
     public class Job {
-        private readonly uint _jobId;
+        private readonly uint _id;
         private readonly Stream _data;
         private readonly long _length;
 
         public Job(uint jobId, Stream data, long length) {
-            _jobId = jobId;
+            _id = jobId;
             _data = data;
             _length = length;
         }
 
-        public uint JobId { get { return _jobId; } }
+        public uint Id { get { return _id; } }
         public Stream Data { get { return _data; } }
         public long DataLength { get { return _length; } }
     }