public void Calls_CreateConnection_when_a_connection_gets_added()
        {
            var input  = placeholderInComponents.Inputs[0];
            var output = placeholderInComponents.Outputs[0];

            operationHandlerMock.Setup(m => m.CreateConnection(virtualStudioName, It.IsAny <StudioConnectionDto>())).Verifiable();

            virtualStudio.CreateConnection(output, input);

            operationHandlerMock.Verify();
        }
        private bool ProcessSync(VirtualStudio virtualStudio)
        {
            var inputComponent = virtualStudio.Components.FirstOrDefault(c => c.Id == inputComponentId);

            if (inputComponent == null)
            {
                Error = new OperationError(ErrorType.NotFound, $"Cannot find component with ID {inputComponentId}.");
                return(false);
            }
            var input = inputComponent.Inputs.FirstOrDefault(i => i.Id == inputId);

            if (input is null)
            {
                Error = new OperationError(ErrorType.NotFound, $"Cannot find input with ID {inputId} on component with ID {inputComponentId}.");
                return(false);
            }
            if (virtualStudio.Connections.FirstOrDefault(c => c.Input == input) != null)
            {
                Error = new OperationError(ErrorType.InvalidOperation, $"Input with ID {inputId} on component with ID {inputComponentId} is already connected.");
                return(false);
            }
            var outputComponent = virtualStudio.Components.FirstOrDefault(c => c.Id == outputComponentId);

            if (outputComponent == null)
            {
                Error = new OperationError(ErrorType.NotFound, $"Cannot find component with ID {outputComponentId}.");
                return(false);
            }
            var output = outputComponent.Outputs.FirstOrDefault(o => o.Id == outputId);

            if (output is null)
            {
                Error = new OperationError(ErrorType.NotFound, $"Cannot find output with ID {outputId} on component with ID {outputComponentId}.");
                return(false);
            }
            if ((input.DataKind & output.DataKind) == DataKind.Nothing)
            {
                Error = new OperationError(ErrorType.InvalidOperation, "DataKind of output and input does not match.");
                return(false);
            }
            if (output.ConnectionType != input.ConnectionType)
            {
                Error = new OperationError(ErrorType.InvalidOperation, "ConnectionType of output and input does not match.");
                return(false);
            }

            if (virtualStudio.CreateConnection(output, input) is null)
            {
                Error = new OperationError(ErrorType.InvalidOperation, $"Cannot create connection for: Output {outputComponentId}:{outputId}, Input {inputComponentId}:{inputId}");
                return(false);
            }
            return(true);
        }
        public void Removes_connection()
        {
            var virtualStudio = new VirtualStudio();
            var placeholder   = new PlaceholderStudioComponent();

            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            var component = virtualStudio.AddComponent(placeholder) as PlaceholderStudioComponent;
            var input     = component.AddInput("input", DataKind.Audio, "ConnectionType");
            var output    = component.AddOutput("output", DataKind.Audio, "ConnectionType");
            IStudioConnection connection = virtualStudio.CreateConnection(output, input);

            virtualStudio.RemoveConnection(connection);

            Assert.IsTrue(virtualStudio.Connections.Count == 0);
        }
        public void Init()
        {
            virtualStudio = new VirtualStudio();

            var placeholder = new PlaceholderStudioComponent();

            placeholder.AddInput("Input 1", DataKind.Audio, "UDP");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            componentWithUdpAudioInput = virtualStudio.AddComponent(placeholder);

            placeholder = new PlaceholderStudioComponent();
            placeholder.AddOutput("Output 1", DataKind.Audio, "UDP");
            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            componentWithUdpAudioOutput = virtualStudio.AddComponent(placeholder);

            connection = virtualStudio.CreateConnection(componentWithUdpAudioOutput.Outputs[0], componentWithUdpAudioInput.Inputs[0]);
        }
        public void Adds_connection_between_endpoints_that_exist_in_components()
        {
            var virtualStudio = new VirtualStudio();
            var placeholder   = new PlaceholderStudioComponent();

            virtualStudio.ComponentRepository.AddPlaceholder(placeholder);
            var component = virtualStudio.AddComponent(placeholder) as PlaceholderStudioComponent;
            var input     = component.AddInput("input", DataKind.Audio, "ConnectionType");
            var output    = component.AddOutput("output", DataKind.Audio, "ConnectionType");

            Assert.IsTrue(virtualStudio.CanCreateConnection(output, input));

            IStudioConnection connection = virtualStudio.CreateConnection(output, input);

            Assert.IsNotNull(connection);
            Assert.IsTrue(virtualStudio.Connections.Count == 1);
        }