Start to port some ircstates tests

5 files changed, 206 insertions, 13 deletions

diff --git a/IrcStates/Emit.cs b/IrcStates/Emit.cs
index 7fc41ae..9af7b62 100644
--- a/IrcStates/Emit.cs
+++ b/IrcStates/Emit.cs
@@ -1,6 +1,23 @@
-namespace IrcStates
+using System.Collections.Generic;
+
+namespace IrcStates
 {
     public class Emit
     {
+        public string Command { get; set; }
+        public string Subcommand { get; set; }
+        public string Text { get; set; }
+        public List<string> Tokens { get; set; }
+        public bool Finished { get; set; }
+        public bool SelfSource { get; set; }
+        public bool SelfTarget { get; set; }
+        public Tests.User User { get; set; }
+        public Tests.User UserSource { get; set; }
+        public Tests.User UserTarget { get; set; }
+        public List<Tests.User> Users { get; set; }
+        public Tests.Channel Channel { get; set; }
+        public Tests.Channel ChannelSource { get; set; }
+        public Tests.Channel ChannelTarget { get; set; }
+        public string Target { get; set; }
     }
 }
diff --git a/IrcStates/Server.cs b/IrcStates/Server.cs
index b9e4ef4..9371a2b 100644
--- a/IrcStates/Server.cs
+++ b/IrcStates/Server.cs
@@ -64,16 +64,22 @@ namespace IrcStates
             return null;
         }
 
-        private Emit ParseTokens(Line line)
+        public Emit ParseTokens(Line line)
         {
-            Emit ret;
-            if (LineHandlers.ContainsKey(line.Command))
-                foreach (var callback in LineHandlers[line.Command])
-                {
-                    var emit = callback(line.Command, line);
-                }
+            if (line != null && !LineHandlers.ContainsKey(line.Command)) return null;
+            var ret = new Emit();
 
-            throw new NotImplementedException();
+            var handlers = LineHandlers[line.Command]
+                .Select(callback => callback(line.Command, line))
+                .Where(emit => emit != null);
+
+            foreach (var emit in handlers)
+            {
+                emit.Command = line.Command;
+                ret          = emit;
+            }
+
+            return ret;
         }
     }
 }
diff --git a/IrcStates/Tests/Cap.cs b/IrcStates/Tests/Cap.cs
index dcd0e50..159490d 100644
--- a/IrcStates/Tests/Cap.cs
+++ b/IrcStates/Tests/Cap.cs
@@ -1,9 +1,130 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+using IrcTokens;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace IrcStates.Tests
 {
     [TestClass]
     public class Cap
     {
+        private Server _server;
+
+        [TestInitialize]
+        public void TestInitialize()
+        {
+            _server = new Server("test");
+        }
+
+        [TestMethod]
+        public void LSOneLine()
+        {
+            Assert.IsFalse(_server.HasCap);
+            CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps);
+            _server.ParseTokens(new Line("CAP * LS :a b"));
+            CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}}, _server.AvailableCaps);
+        }
+
+        [TestMethod]
+        public void LSTwoLines()
+        {
+            _server.ParseTokens(new Line("CAP * LS * :a b"));
+            CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps);
+            _server.ParseTokens(new Line("CAP * LS :c"));
+            CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}, {"c", ""}},
+                _server.AvailableCaps);
+        }
+
+        [TestMethod]
+        public void LSValues()
+        {
+            _server.ParseTokens(new Line("CAP * LS :a b= c=1"));
+            CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}, {"c", "1"}},
+                _server.AvailableCaps);
+        }
+
+        [TestMethod]
+        public void ACKOneLine()
+        {
+            _server.ParseTokens(new Line("CAP * LS :a b"));
+            _server.ParseTokens(new Line("CAP * ACK :a b"));
+            CollectionAssert.AreEqual(new List<string> {"a", "b"}, _server.AgreedCaps);
+        }
+
+        [TestMethod]
+        public void ACKTwoLines()
+        {
+            _server.ParseTokens(new Line("CAP * LS :a b c"));
+            _server.ParseTokens(new Line("CAP * ACK * :a b"));
+            _server.ParseTokens(new Line("CAP * ACK :c"));
+            CollectionAssert.AreEqual(new List<string> {"a", "b", "c"}, _server.AgreedCaps);
+        }
+
+        [TestMethod]
+        public void ACKNotLS()
+        {
+            _server.ParseTokens(new Line("CAP * LS a"));
+            _server.ParseTokens(new Line("CAP * ACK b"));
+            CollectionAssert.AreEqual(new List<string>(), _server.AgreedCaps);
+        }
+
+        [TestMethod]
+        public void NEWNoLS()
+        {
+            _server.ParseTokens(new Line("CAP * NEW :a"));
+            CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}}, _server.AvailableCaps);
+        }
+
+        [TestMethod]
+        public void NEWOneLine()
+        {
+            _server.ParseTokens(new Line("CAP * LS :a"));
+            _server.ParseTokens(new Line("CAP * NEW :b"));
+            CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}}, _server.AvailableCaps);
+        }
+
+        [TestMethod]
+        public void NEWTwoLines()
+        {
+            _server.ParseTokens(new Line("CAP * LS :a"));
+            _server.ParseTokens(new Line("CAP * NEW :b c"));
+            CollectionAssert.AreEqual(new Dictionary<string, string> {{"a", ""}, {"b", ""}, {"c", ""}},
+                _server.AvailableCaps);
+        }
+
+        [TestMethod]
+        public void DELNotAcked()
+        {
+            _server.ParseTokens(new Line("CAP * DEL a"));
+        }
+
+        [TestMethod]
+        public void DELOneLS()
+        {
+            _server.ParseTokens(new Line("CAP * LS :a"));
+            _server.ParseTokens(new Line("CAP * ACK :a"));
+            _server.ParseTokens(new Line("CAP * DEL :a"));
+            CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps);
+            CollectionAssert.AreEqual(new List<string>(), _server.AgreedCaps);
+        }
+
+        [TestMethod]
+        public void DELTwoLS()
+        {
+            _server.ParseTokens(new Line("CAP * LS :a b"));
+            _server.ParseTokens(new Line("CAP * ACK :a b"));
+            _server.ParseTokens(new Line("CAP * DEL :a"));
+            CollectionAssert.AreEqual(new Dictionary<string, string> {{"b", ""}}, _server.AvailableCaps);
+            CollectionAssert.AreEqual(new List<string> {"b"}, _server.AgreedCaps);
+        }
+
+        [TestMethod]
+        public void DELTwoDEL()
+        {
+            _server.ParseTokens(new Line("CAP * LS :a b"));
+            _server.ParseTokens(new Line("CAP * ACK :a b"));
+            _server.ParseTokens(new Line("CAP * DEL :a b"));
+            CollectionAssert.AreEqual(new Dictionary<string, string>(), _server.AvailableCaps);
+            CollectionAssert.AreEqual(new List<string>(), _server.AgreedCaps);
+        }
     }
 }
diff --git a/IrcStates/Tests/Casemap.cs b/IrcStates/Tests/Casemap.cs
index fef9a31..7d78ee1 100644
--- a/IrcStates/Tests/Casemap.cs
+++ b/IrcStates/Tests/Casemap.cs
@@ -1,9 +1,58 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using IrcTokens;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace IrcStates.Tests
 {
     [TestClass]
     public class Casemap
     {
+        [TestMethod]
+        public void Rfc1459()
+        {
+            var lower = IrcStates.Casemap.CaseFold(IrcStates.Casemap.CaseMapping.Rfc1459, @"ÀTEST[]~\");
+            Assert.AreEqual("Àtest{}^|", lower);
+        }
+
+        [TestMethod]
+        public void Ascii()
+        {
+            var lower = IrcStates.Casemap.CaseFold(IrcStates.Casemap.CaseMapping.Ascii, @"ÀTEST[]~\");
+            Assert.AreEqual(@"Àtest[]~\", lower);
+        }
+
+        [TestMethod]
+        public void CommandJoin()
+        {
+            var server = new Server("test");
+            server.ParseTokens(new Line("001 nickname"));
+            server.ParseTokens(new Line(":Nickname JOIN #Chan"));
+            server.ParseTokens(new Line(":Other JOIN #Chan"));
+
+            Assert.IsTrue(server.Users.ContainsKey("nickname"));
+            Assert.IsFalse(server.Users.ContainsKey("Nickname"));
+            Assert.IsTrue(server.Users.ContainsKey("other"));
+            Assert.IsFalse(server.Users.ContainsKey("Other"));
+            Assert.IsTrue(server.Channels.ContainsKey("#chan"));
+            Assert.IsFalse(server.Channels.ContainsKey("#Chan"));
+
+            var channel = server.Channels["#chan"];
+            Assert.AreEqual("#Chan", channel.Name);
+        }
+
+        [TestMethod]
+        public void CommandNick()
+        {
+            var server = new Server("test");
+            server.ParseTokens(new Line("001 nickname"));
+            server.ParseTokens(new Line(":nickname JOIN #chan"));
+            var user = server.Users["nickname"];
+            server.ParseTokens(new Line(":nickname NICK NewNickname"));
+            Assert.AreEqual(1, server.Users.Count);
+            Assert.IsTrue(server.Users.ContainsKey("newnickname"));
+            Assert.AreEqual("NewNickname", user.NickName);
+            Assert.AreEqual("newnickname", user.NickNameLower);
+            Assert.AreEqual("NewNickName", server.NickName);
+            Assert.AreEqual("newnickname", server.NickNameLower);
+        }
     }
 }
diff --git a/IrcStates/User.cs b/IrcStates/User.cs
index 3fea024..b9a9570 100644
--- a/IrcStates/User.cs
+++ b/IrcStates/User.cs
@@ -4,8 +4,8 @@ namespace IrcStates
 {
     public class User
     {
-        private string NickName;
-        private string NickNameLower;
+        public string NickName { get; set; }
+        public string NickNameLower { get; set; }
 
         public string UserName { get; set; }
         public string HostName { get; set; }