Exemple #1
0
        void AddRemoteServer(Connection connection, IDomainOfResponsibility dor, IDomainOfInterest doi, Guid syncID)
        {
            if (syncID == ServerSync.LocalServer.SyncID)
            {
                return;
            }

            var newServer = new RemoteServerImpl(connection, doi, dor, syncID);

            lock (remoteServers)
                remoteServers.Add(connection, newServer);

            if (AddedServer != null)
            {
                AddedServer(this, new ServerEventArgs(newServer));
            }

            connection.Closed += delegate(object sender, EventArgs args)
            {
                lock (remoteServers)
                    remoteServers.Remove(connection);

                if (RemovedServer != null)
                {
                    RemovedServer(this, new ServerEventArgs(newServer));
                }
            };
        }
Exemple #2
0
        public void MockGlobalObjects()
        {
            handlers             = new Mock <IHandlers>();
            remoteConnectionMock = new Mock <Connection>();
            remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "addEntity"))
            .Returns((ClientFunction)handlers.Object.AddEntity);
            remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "removeEntity"))
            .Returns((ClientFunction)handlers.Object.RemoveEntity);
            remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "changeAttributes"))
            .Returns((ClientFunction)handlers.Object.ChangeAttributes);

            doiMock = new Mock <IDomainOfInterest>();
            dorMock = new Mock <IDomainOfResponsibility>();
            doiMock.Setup(doi => doi.IsInterestedInEntity(It.IsAny <Entity>())).Returns(true);
            doiMock.Setup(doi => doi.IsInterestedInAttributeChange(It.IsAny <Entity>(), It.IsAny <string>(),
                                                                   It.IsAny <string>())).Returns(true);
            dorMock.Setup(dor => dor.IsResponsibleFor(It.IsAny <Entity>())).Returns(true);


            localServiceMock = new Mock <ServiceImplementation>();
            localServerMock  = new Mock <ILocalServer>();
            localServerMock.SetupGet(ls => ls.Service).Returns(localServiceMock.Object);
            localServerMock.SetupGet(ls => ls.DoI).Returns(doiMock.Object);
            localServerMock.SetupGet(ls => ls.DoR).Returns(dorMock.Object);

            remoteServer = new RemoteServerImpl(remoteConnectionMock.Object, doiMock.Object, dorMock.Object,
                                                Guid.NewGuid());

            serverSyncMock = new Mock <IServerSync>();
            serverSyncMock.Setup(ss => ss.RemoteServers).Returns(new List <IRemoteServer> {
                remoteServer
            });
            serverSyncMock.Setup(ss => ss.LocalServer).Returns(localServerMock.Object);

            var componentDefinition = new ComponentDefinition("test");

            componentDefinition.AddAttribute <int>("a", 42);

            componentRegistryMock = new Mock <IComponentRegistry>();
            componentRegistryMock.SetupGet(cr => cr.RegisteredComponents).Returns(
                new ReadOnlyCollection <ReadOnlyComponentDefinition>(new List <ReadOnlyComponentDefinition>()));
            componentRegistryMock.Setup(cr => cr.FindComponentDefinition("test"))
            .Returns(componentDefinition);

            serializationMock = new Mock <IStringSerialization>();

            ServerSync.Instance          = serverSyncMock.Object;
            ComponentRegistry.Instance   = componentRegistryMock.Object;
            StringSerialization.Instance = serializationMock.Object;
            World.Instance = new World();

            ServiceBus.Instance = new ServiceBusImplementation();
            ServiceBus.Instance.Initialize();
        }
Exemple #3
0
        public void ShouldForwardUpdatesToServersOtherThanTheSource()
        {
            var otherConnectionMock = new Mock <Connection>();
            var handlers2           = new Mock <IHandlers>();

            otherConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "addEntity"))
            .Returns((ClientFunction)handlers2.Object.AddEntity);
            otherConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "removeEntity"))
            .Returns((ClientFunction)handlers2.Object.RemoveEntity);
            otherConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "changeAttributes"))
            .Returns((ClientFunction)handlers2.Object.ChangeAttributes);

            var guid = Guid.NewGuid();
            RemoteServerImpl remoteServer2 = new RemoteServerImpl(otherConnectionMock.Object, doiMock.Object,
                                                                  dorMock.Object, guid);

            serverSyncMock.Setup(ss => ss.RemoteServers).Returns(
                new List <IRemoteServer> {
                remoteServer, remoteServer2
            });

            var changedAttributes = new EntitySyncInfo();

            changedAttributes["test"]["a"] = new AttributeSyncInfo(Guid.NewGuid().ToString(), 99);

            var entity    = new Entity();
            var worldSync = new WorldSync();

            worldSync.HandleRemoteAddedEntity(remoteConnectionMock.Object, entity.Guid.ToString(), entity.Owner.ToString(), new EntitySyncInfo());
            worldSync.HandleRemoteChangedAttributes(remoteConnectionMock.Object, entity.Guid.ToString(), changedAttributes);
            worldSync.HandleRemoteRemovedEntity(remoteConnectionMock.Object, entity.Guid.ToString());

            handlers.Verify(h => h.AddEntity(entity.Guid.ToString(), It.IsAny <EntitySyncInfo>()), Times.Never());
            handlers.Verify(h => h.ChangeAttributes(entity.Guid.ToString(), It.IsAny <EntitySyncInfo>()), Times.Never());
            handlers.Verify(h => h.RemoveEntity(entity.Guid.ToString()), Times.Never());

            handlers2.Verify(h => h.AddEntity(entity.Guid.ToString(), entity.Owner.ToString(), It.IsAny <EntitySyncInfo>()), Times.Once());
            handlers2.Verify(h => h.ChangeAttributes(entity.Guid.ToString(), It.IsAny <EntitySyncInfo>()), Times.Once());
            handlers2.Verify(h => h.RemoveEntity(entity.Guid.ToString()), Times.Once());
        }
Exemple #4
0
        public void MockGlobalObjects()
        {
            handlers             = new Mock <IHandlers>();
            remoteConnectionMock = new Mock <Connection>();
            remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "updateDoI"))
            .Returns((ClientFunction)handlers.Object.UpdateDoI);
            remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "updateDoR"))
            .Returns((ClientFunction)handlers.Object.UpdateDoR);

            doiMock          = new Mock <IDomainOfInterest>();
            dorMock          = new Mock <IDomainOfResponsibility>();
            localServiceMock = new Mock <ServiceImplementation>();
            localServerMock  = new Mock <ILocalServer>();
            localServerMock.SetupGet(ls => ls.Service).Returns(localServiceMock.Object);
            localServerMock.SetupGet(ls => ls.DoI).Returns(doiMock.Object);
            localServerMock.SetupGet(ls => ls.DoR).Returns(dorMock.Object);

            remoteServer = new RemoteServerImpl(remoteConnectionMock.Object, doiMock.Object, dorMock.Object,
                                                Guid.NewGuid());

            var serverSyncMock = new Mock <IServerSync>();

            serverSyncMock.Setup(ss => ss.RemoteServers).Returns(new List <IRemoteServer> {
                remoteServer
            });
            serverSyncMock.Setup(ss => ss.LocalServer).Returns(localServerMock.Object);

            componentRegistryMock = new Mock <IComponentRegistry>();
            componentRegistryMock.SetupGet(cr => cr.RegisteredComponents).Returns(
                new ReadOnlyCollection <ReadOnlyComponentDefinition>(new List <ReadOnlyComponentDefinition>()));

            serializationMock = new Mock <IStringSerialization>();

            ServerSync.Instance          = serverSyncMock.Object;
            ComponentRegistry.Instance   = componentRegistryMock.Object;
            StringSerialization.Instance = serializationMock.Object;
        }
        public void MockGlobalObjects()
        {
            handlers = new Mock<IHandlers>();
            remoteConnectionMock = new Mock<Connection>();
            remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "addEntity"))
                .Returns((ClientFunction)handlers.Object.AddEntity);
            remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "removeEntity"))
                .Returns((ClientFunction)handlers.Object.RemoveEntity);
            remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "changeAttributes"))
                .Returns((ClientFunction)handlers.Object.ChangeAttributes);

            doiMock = new Mock<IDomainOfInterest>();
            dorMock = new Mock<IDomainOfResponsibility>();
            doiMock.Setup(doi => doi.IsInterestedInEntity(It.IsAny<Entity>())).Returns(true);
            doiMock.Setup(doi => doi.IsInterestedInAttributeChange(It.IsAny<Entity>(), It.IsAny<string>(),
                It.IsAny<string>())).Returns(true);
            dorMock.Setup(dor => dor.IsResponsibleFor(It.IsAny<Entity>())).Returns(true);

            localServiceMock = new Mock<ServiceImplementation>();
            localServerMock = new Mock<ILocalServer>();
            localServerMock.SetupGet(ls => ls.Service).Returns(localServiceMock.Object);
            localServerMock.SetupGet(ls => ls.DoI).Returns(doiMock.Object);
            localServerMock.SetupGet(ls => ls.DoR).Returns(dorMock.Object);

            remoteServer = new RemoteServerImpl(remoteConnectionMock.Object, doiMock.Object, dorMock.Object,
                Guid.NewGuid());

            serverSyncMock = new Mock<IServerSync>();
            serverSyncMock.Setup(ss => ss.RemoteServers).Returns(new List<IRemoteServer> { remoteServer });
            serverSyncMock.Setup(ss => ss.LocalServer).Returns(localServerMock.Object);

            var componentDefinition = new ComponentDefinition("test");
            componentDefinition.AddAttribute<int>("a", 42);

            componentRegistryMock = new Mock<IComponentRegistry>();
            componentRegistryMock.SetupGet(cr => cr.RegisteredComponents).Returns(
                new ReadOnlyCollection<ReadOnlyComponentDefinition>(new List<ReadOnlyComponentDefinition>()));
            componentRegistryMock.Setup(cr => cr.FindComponentDefinition("test"))
                .Returns(componentDefinition);

            serializationMock = new Mock<IStringSerialization>();

            ServerSync.Instance = serverSyncMock.Object;
            ComponentRegistry.Instance = componentRegistryMock.Object;
            StringSerialization.Instance = serializationMock.Object;
            World.Instance = new World();

            ServiceBus.Instance = new ServiceBusImplementation();
            ServiceBus.Instance.Initialize();
        }
        public void ShouldForwardUpdatesToServersOtherThanTheSource()
        {
            var otherConnectionMock = new Mock<Connection>();
            var handlers2 = new Mock<IHandlers>();
            otherConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync","addEntity"))
                .Returns((ClientFunction)handlers2.Object.AddEntity);
            otherConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync","removeEntity"))
                .Returns((ClientFunction)handlers2.Object.RemoveEntity);
            otherConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "changeAttributes"))
                .Returns((ClientFunction)handlers2.Object.ChangeAttributes);

            var guid = Guid.NewGuid();
            RemoteServerImpl remoteServer2 = new RemoteServerImpl(otherConnectionMock.Object, doiMock.Object,
                dorMock.Object, guid);
            serverSyncMock.Setup(ss => ss.RemoteServers).Returns(
                new List<IRemoteServer> { remoteServer, remoteServer2 });

            var changedAttributes = new EntitySyncInfo();
            changedAttributes["test"]["a"] = new AttributeSyncInfo(Guid.NewGuid(), 99);

            var entity = new Entity();
            var worldSync = new WorldSync();
            worldSync.HandleRemoteAddedEntity(remoteConnectionMock.Object, entity.Guid, entity.Owner, new EntitySyncInfo());
            worldSync.HandleRemoteChangedAttributes(remoteConnectionMock.Object, entity.Guid, changedAttributes);
            worldSync.HandleRemoteRemovedEntity(remoteConnectionMock.Object, entity.Guid);

            handlers.Verify(h => h.AddEntity(entity.Guid, It.IsAny<EntitySyncInfo>()), Times.Never());
            handlers.Verify(h => h.ChangeAttributes(entity.Guid, It.IsAny<EntitySyncInfo>()), Times.Never());
            handlers.Verify(h => h.RemoveEntity(entity.Guid), Times.Never());

            handlers2.Verify(h => h.AddEntity(entity.Guid, It.IsAny<EntitySyncInfo>()), Times.Once());
            handlers2.Verify(h => h.ChangeAttributes(entity.Guid, It.IsAny<EntitySyncInfo>()), Times.Once());
            handlers2.Verify(h => h.RemoveEntity(entity.Guid), Times.Once());
        }
        void AddRemoteServer(Connection connection, IDomainOfResponsibility dor, IDomainOfInterest doi, Guid syncID)
        {
            if (syncID == ServerSync.LocalServer.SyncID)
                return;

            var newServer = new RemoteServerImpl(connection, doi, dor, syncID);

            lock (remoteServers)
                remoteServers.Add(connection, newServer);

            if (AddedServer != null)
                AddedServer(this, new ServerEventArgs(newServer));

            connection.Closed += delegate(object sender, EventArgs args)
            {
                lock (remoteServers)
                    remoteServers.Remove(connection);

                if (RemovedServer != null)
                    RemovedServer(this, new ServerEventArgs(newServer));
            };
        }
        public void MockGlobalObjects()
        {
            handlers = new Mock<IHandlers>();
            remoteConnectionMock = new Mock<Connection>();
            remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "updateDoI"))
                .Returns((ClientFunction)handlers.Object.UpdateDoI);
            remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "updateDoR"))
                .Returns((ClientFunction)handlers.Object.UpdateDoR);

            doiMock = new Mock<IDomainOfInterest>();
            dorMock = new Mock<IDomainOfResponsibility>();
            localServiceMock = new Mock<ServiceImplementation>();
            localServerMock = new Mock<ILocalServer>();
            localServerMock.SetupGet(ls => ls.Service).Returns(localServiceMock.Object);
            localServerMock.SetupGet(ls => ls.DoI).Returns(doiMock.Object);
            localServerMock.SetupGet(ls => ls.DoR).Returns(dorMock.Object);

            remoteServer = new RemoteServerImpl(remoteConnectionMock.Object, doiMock.Object, dorMock.Object,
                Guid.NewGuid());

            var serverSyncMock = new Mock<IServerSync>();
            serverSyncMock.Setup(ss => ss.RemoteServers).Returns(new List<IRemoteServer> { remoteServer });
            serverSyncMock.Setup(ss => ss.LocalServer).Returns(localServerMock.Object);

            componentRegistryMock = new Mock<IComponentRegistry>();
            componentRegistryMock.SetupGet(cr => cr.RegisteredComponents).Returns(
                new ReadOnlyCollection<ReadOnlyComponentDefinition>(new List<ReadOnlyComponentDefinition>()));

            serializationMock = new Mock<IStringSerialization>();

            ServerSync.Instance = serverSyncMock.Object;
            ComponentRegistry.Instance = componentRegistryMock.Object;
            StringSerialization.Instance = serializationMock.Object;
        }