public void ChainLinkFactory_ShouldReturnManyToOneConveyor_Correctly()
        {
            using (var mock = AutoMock.GetLoose())
            {
                // The AutoMock class will inject a mock IDepsendency
                // into the SystemUnderTest constructor
                var sut      = mock.Create <ChainLinkFactory>();
                var nodeData = new NodeCreationData()
                {
                    Id        = Guid.NewGuid().ToString(),
                    NextNodes = null,
                    Type      = BuildingComponentType.ManyToOneConveyor
                };
                var simulationSettings = new SimulationSettings()
                {
                    Nodes = new List <NodeCreationData>()
                    {
                        nodeData
                    }
                };

                var resultNode = sut.CreateChainLink(nodeData, simulationSettings);

                resultNode.ShouldBeOfType <ManyToOneConveyor>();
            }
        }
Example #2
0
        public static List <NodeCreationData> SerializedToCreation(List <NodeCreationData> importedData)
        {
            var serializedData = importedData;

            serializedData.Reverse();
            int lenght = 0;

            foreach (NodeCreationData component in serializedData)
            {
                if (!ListedForCreation.Contains(component.Id))
                {
                    lenght++;
                    var nextNode = component.NextNodes.Keys.FirstOrDefault();
                    if (nextNode == null || nextNode.Type != component.Type)
                    {
                        NodeCreationData nodeData = new NodeCreationData();

                        nodeData.Id     = component.Id;
                        nodeData.Length = lenght;
                        if (component.ConveyorIndex != null)
                        {
                            nodeData.ConveyorIndex = component.ConveyorIndex;
                        }
                        nodeData.NextNodes = component.NextNodes;
                        nodeData.Type      = component.Type;

                        lenght = 0;
                        NodesCreationData.Add(nodeData);
                        //ListedForCreation.Add(component.Id);
                    }
                }
            }

            return(NodesCreationData);
        }
        public void ChainLinkFactory_CreateAaDispatcher_ShouldReturnNodeWithRandomGuid()
        {
            using (var mock = AutoMock.GetLoose((a) => { a.RegisterType <TimerService>().AsImplementedInterfaces(); }))
            {
                var timerService = mock.Create <ITimerService>();
                var sut          = mock.Create <ChainLinkFactory>();
                var nodeData     = new NodeCreationData()
                {
                    Id        = Guid.NewGuid().ToString(),
                    NextNodes = null,
                    Type      = BuildingComponentType.Conveyor
                };
                var simulationSettings = new SimulationSettings()
                {
                    Nodes = new List <NodeCreationData>()
                    {
                        nodeData
                    }
                };

                sut.SetSettings(simulationSettings);

                var resultNode = sut.CreateAaDispatcher();

                Guid.TryParse(resultNode.NodeId, out Guid output).ShouldBe(true);
            }
        }
        public void ChainLinkFactory_CreateBagCollector_ShouldReturnNodeWithRandomGuid()
        {
            using (var mock = AutoMock.GetLoose())
            {
                // The AutoMock class will inject a mock IDependency
                // into the SystemUnderTest constructor
                var sut      = mock.Create <ChainLinkFactory>();
                var nodeData = new NodeCreationData()
                {
                    Id        = Guid.NewGuid().ToString(),
                    NextNodes = null,
                    Type      = BuildingComponentType.Conveyor
                };
                var simulationSettings = new SimulationSettings()
                {
                    Nodes = new List <NodeCreationData>()
                    {
                        nodeData
                    }
                };

                sut.SetSettings(simulationSettings);

                var resultNode = sut.CreateBagCollector();

                Guid.TryParse(resultNode.NodeId, out Guid output).ShouldBe(true);
            }
        }
Example #5
0
        public IChainLink CreateChainLink(NodeCreationData nodeData, SimulationSettings settings)
        {
            switch (nodeData.Type)
            {
            case BuildingComponentType.CheckIn:
                return(_checkInDeskFactory.Invoke(nodeData.Id));

            case BuildingComponentType.PSC:
                return(_pscFactory.Invoke(settings.Pscs, nodeData.Id));

            case BuildingComponentType.ASC:
                return(_ascFactory.Invoke(settings.Ascs, nodeData.Id));

            case BuildingComponentType.MPA:
                return(_mpaFactory.Invoke(nodeData.Id));

            case BuildingComponentType.BSU:
                return(_bsuFactory.Invoke(nodeData.Id));

            case BuildingComponentType.AA:
                return(_aaFactory.Invoke(_gatesCount++, nodeData.Id));

            case BuildingComponentType.PA:
                return(_puaFactory.Invoke(_puasCount++, nodeData.Id));

            case BuildingComponentType.Conveyor:
                return(_oneToOneConveyorFactory.Invoke(nodeData.Length ?? 0, nodeData.Id));

            case BuildingComponentType.ManyToOneConveyor:
                return(_manyToOneConveyorFactory.Invoke(nodeData.Length ?? 0, nodeData.Id));

            default:
                throw new ArgumentException("Unsupported node type");
            }
        }
Example #6
0
        public void NodeConnectorService()
        {
            using (var mock = AutoMock.GetLoose((a) =>
            {
                a.RegisterType <ChainLinkFactory>().AsImplementedInterfaces();
                a.RegisterType <ConveyorConnector>().AsImplementedInterfaces();
            }))
            {
                var factoryMock = new Mock <IChainLinkFactory>();
                factoryMock.Setup(f => f.CreateConveyorConnector()).Returns(new Mock <IConveyorConnector>().Object);
                var connector = new NodeConnectorService(factoryMock.Object);

                var checkInDispatcherMock = new Mock <ICheckInDispatcher>();
                var aaDispatcherMock      = new Mock <IAADispatcher>();
                var bagCollectorMock      = new Mock <IBagCollector>();
                var checkInMock           = new Mock <ICheckInDesk>();
                checkInMock.Setup(m => m.NodeId).Returns(Guid.NewGuid().ToString());
                var manyToOneConveyorMock = new Mock <IManyToOneConveyor>();
                manyToOneConveyorMock.Setup(m => m.NodeId).Returns(Guid.NewGuid().ToString());

                var nodeDataConveyor = new NodeCreationData()
                {
                    Id        = manyToOneConveyorMock.Object.NodeId,
                    NextNodes = null,
                    Type      = BuildingComponentType.ManyToOneConveyor
                };
                var nodeDataCheckIn = new NodeCreationData()
                {
                    Id        = checkInMock.Object.NodeId,
                    NextNodes = new Dictionary <NodeCreationData, int?>()
                    {
                        { nodeDataConveyor, 0 }
                    },
                    Type = BuildingComponentType.CheckIn
                };

                var simulationSettings = new SimulationSettings()
                {
                    Nodes = new List <NodeCreationData>()
                    {
                        nodeDataConveyor, nodeDataCheckIn
                    }
                };

                var nodes = new List <IChainLink>()
                {
                    bagCollectorMock.Object,
                    aaDispatcherMock.Object,
                    checkInDispatcherMock.Object,
                    checkInMock.Object,
                    manyToOneConveyorMock.Object
                };

                connector.ConnectNodes(nodes, simulationSettings.Nodes);
            }
        }
Example #7
0
        public void NodeConnectorService_ShouldAttachEndNodes()
        {
            using (var mock = AutoMock.GetLoose((a) =>
            {
                a.RegisterType <ChainLinkFactory>().AsImplementedInterfaces();
                a.RegisterType <ConveyorConnector>().AsImplementedInterfaces();
            }))
            {
                var factoryMock = new Mock <IChainLinkFactory>();
                factoryMock.Setup(f => f.CreateConveyorConnector()).Returns(new Mock <IConveyorConnector>().Object);
                var connector = new NodeConnectorService(factoryMock.Object);

                var conveyorId = Guid.NewGuid().ToString();
                var aaId       = Guid.NewGuid().ToString();

                var checkInDispatcherMock = new Mock <ICheckInDispatcher>();
                var aaDispatcherMock      = new Mock <IAADispatcher>();
                var bagCollectorMock      = new Mock <IBagCollector>();
                var conveyorMock          = new Mock <IOneToOneConveyor>();
                conveyorMock.Setup(m => m.NodeId).Returns(conveyorId);
                var aaMock = new Mock <IAa>();
                aaMock.Setup(m => m.NodeId).Returns(aaId);
                aaMock.Setup(m => m.AddSuccessor(bagCollectorMock.Object));

                var aa = new NodeCreationData()
                {
                    Id        = aaId,
                    NextNodes = null,
                    Type      = BuildingComponentType.AA
                };
                var conveyor = new NodeCreationData()
                {
                    Id        = conveyorId,
                    NextNodes = new Dictionary <NodeCreationData, int?>()
                    {
                        { aa, 0 }
                    },
                    Type = BuildingComponentType.Conveyor
                };

                var simulationSettings = new SimulationSettings()
                {
                    Nodes = new List <NodeCreationData>()
                    {
                        aa, conveyor
                    }
                };

                var nodes = new List <IChainLink>()
                {
                    bagCollectorMock.Object,
                    aaDispatcherMock.Object,
                    checkInDispatcherMock.Object,
                    conveyorMock.Object,
                    aaMock.Object
                };

                connector.ConnectNodes(nodes, simulationSettings.Nodes);

                aaMock.Verify(m => m.AddSuccessor(bagCollectorMock.Object), Times.Once);
            }
        }