private static void Main(string[] args)
{
var db = new Database.Database("db.txt", new DbSerializer());
var registry = new HandlersRegistry();
registry.Reg(new AddGood().GetType(), new AddGoodCommandHandler(db));
registry.Reg(new AddCategory().GetType(), new AddCategoryCommandHandler(db));
registry.Reg(new AddUser().GetType(), new AddUserCommandHandler(db));
registry.Reg(new RemoveGood().GetType(), new RemoveGoodCommandHandler(db));
registry.Reg(new RemoveCategory().GetType(), new RemoveCategoryCommandHandler(db));
registry.Reg(new RemoveUser().GetType(), new RemoveUserCommandHandler(db));
registry.Reg(new AddReference().GetType(), new AddReferenceCommandHandler(db));
registry.Reg(new RemoveReference().GetType(), new RemoveReferenceCommandHandler(db));
registry.Reg(new SelectByCategoryId().GetType(), new SelectByCategoryIdCommandHandler(db));
registry.Reg(new SelectByUserId().GetType(), new SelectByUserIdCommandHandler(db));
registry.Reg(new SelectByGoodId().GetType(), new SelectByGoodIdCommandHandler(db));
registry.Reg(new GetData().GetType(), new GetDataCommandHandler(db));
registry.RegDefault(new DefaultCommandHandler(db));
var tcpServer = new TcpServer(17777, registry, new Serializer.Serializer());
Console.ReadKey();
tcpServer.EndAccepting();
}
public async Task Receives_Data_Over_Socket_Transport()
{
var transmittedMessages = new List <byte[]>();
var receivedMessages = new List <byte[]>();
var receiveEvent = new ManualResetEventSlim();
HandlersRegistry.RegisterReceiveBufferHandler(reader =>
{
var data = reader.Read().ToArray();
receivedMessages.Add(data);
reader.Advance(data.Length);
receiveEvent.Set();
});
await OpenConnectionAsync();
foreach (var _ in new object[IterationCount])
{
var transmittingData = Guid.NewGuid().ToByteArray();
await acceptedSocket.SendAsync(transmittingData, default);
transmittedMessages.Add(transmittingData);
Assert.True(receiveEvent.Wait(waitTimeout));
receiveEvent.Reset();
}
Assert.Equal(transmittedMessages, receivedMessages);
}
public void Sends_Stream_Header_To_Transmit_Pipe()
{
var sentHeader = default(XmlElement);
HandlersRegistry.RegisterTransmitPipeHandler <XmlElement>(request => sentHeader = request);
MessageSender.SendTransportMessage(TransportMessage.Opened);
Assert.NotNull(sentHeader);
Assert.Equal("stream:stream", sentHeader.Name);
}
public TcpServer(int port, HandlersRegistry reg, Serializer.Serializer serializer)
{
Serializer = serializer;
Registry = reg;
Server = new TcpListener(GetLocalIp(), port);
Server.Start();
StartAccepting();
Console.WriteLine("Server started at " + Server.LocalEndpoint);
}
public async Task SendUnsubscribeRequestAsync_Sends_Correct_Presence_Stanza()
{
var subscriptionJid = $"{Guid.NewGuid()}@domain.com";
var expectedStanza = PresenceStanza.New(PresenceStanza.Type.Unsubscribe).To(subscriptionJid);
var actualStanza = default(XmlElement);
HandlersRegistry.RegisterTransmitPipeHandler <XmlElement>(e => actualStanza = e);
await MessageSender.SendUnsubscribeRequestAsync(subscriptionJid);
Assert.Equal(expectedStanza, actualStanza);
}
public async Task SendRosterItemUpdateAsync_Sends_Correct_Request_Stanza()
{
var item = new RosterItem("*****@*****.**", "user");
var expectedStanza = CreateRosterStanza(IqStanza.Type.Set, item).From(jid);
var actualStanza = default(XmlElement);
HandlersRegistry.RegisterTransmitPipeHandler <XmlElement>(s => actualStanza = s);
var requestId = await MessageSender.SendRosterItemUpdateAsync(jid, item);
expectedStanza.Id(requestId);
Assert.Equal(expectedStanza, actualStanza);
}
public async Task SendRosterRequestAsync_Sends_Roster_Request_Stanza()
{
var expectedStanza = CreateRosterStanza(IqStanza.Type.Get).From(jid);
var actualStanza = default(XmlElement);
HandlersRegistry.RegisterTransmitPipeHandler <XmlElement>(s => actualStanza = s);
var requestId = await MessageSender.SendRosterRequestAsync(jid);
expectedStanza.Id(requestId);
Assert.False(string.IsNullOrEmpty(requestId));
Assert.Equal(expectedStanza, actualStanza);
}
public SocketTransportTests() : base(services =>
{
var port = BasePort + Guid.NewGuid().ToByteArray()[0];
services.AddClientSocket("localhost", port)
.AddSocketListener(IPAddress.IPv6Loopback, port);
})
{
acceptEvent = new();
HandlersRegistry.RegisterHandler <SocketAcceptedEvent>(@event =>
{
acceptedSocket = @event.Socket;
@event.SocketAcquired = true;
acceptEvent.Set();
});
var filter = GetRequiredService <ISerializationFilter>();
filter.AddSerializer <Guid>((writer, guid) => writer.Write(guid.ToByteArray()));
}
public void Can_Negotiate_Tls_Feature()
{
XmlElement sentElement = default;
bool? setTlsSend = default;
var featuresResponse = new XmlElement("stream:features", new XmlElement("starttls").Xmlns(XmppNamespaces.Tls));
HandlersRegistry.RegisterTransmitPipeHandler <XmlElement>(request => sentElement = request);
HandlersRegistry.RegisterTransportMessageHandler(TransportMessage.SetTls, () => setTlsSend = true);
MessageSender.SendTransportMessage(TransportMessage.Opened);
MessageSender.SendToReceivePipe(StreamHeader.Client());
MessageSender.SendToReceivePipe(featuresResponse);
Assert.Equal("starttls", sentElement.Name);
MessageSender.SendToReceivePipe(new XmlElement("proceed").Xmlns(XmppNamespaces.Tls));
Assert.True(setTlsSend);
}
public async Task SendStatusUpdateAsync_Sends_Correct_Presence_Stanza()
{
var expectedStatus = new PresenceStatus
{
AvailabilitySubstate = AvailabilitySubstate.Chat,
StatusText = Guid.NewGuid().ToString()
};
var token = new CancellationToken();
var sentStanza = default(XmlElement);
HandlersRegistry.RegisterTransmitPipeHandler <XmlElement>(e => sentStanza = e);
await MessageSender.SendStatusUpdateAsync(expectedStatus, token);
Assert.NotNull(sentStanza);
Assert.Equal(expectedStatus.StatusText, sentStanza.Child("status").Value);
Assert.Equal(expectedStatus.AvailabilitySubstate.ToString().ToLower(), sentStanza.Child("show").Value);
}
public async Task SendRosterItemRemoveRequestAsync_Sends_Correct_Request_Stanza()
{
var item = new RosterItem("*****@*****.**", "user");
var expectedStanza = CreateRosterStanza(IqStanza.Type.Set, item).From(jid);
var itemElement = expectedStanza.Child("query").Child("item");
itemElement.SetAttributeValue("subscription", "remove");
var actualStanza = default(XmlElement);
HandlersRegistry.RegisterTransmitPipeHandler <XmlElement>(s => actualStanza = s);
var requestId = await MessageSender.SendRosterItemRemoveRequestAsync(jid, item);
expectedStanza.Id(requestId);
Assert.Equal(expectedStanza, actualStanza);
}
