public void NewAzureDedicatedCircuitSuccessful()
        {
            // Setup

            string circuitName         = "TestCircuit";
            uint   bandwidth           = 10;
            string serviceProviderName = "TestProvider";
            string location            = "us-west";
            string serviceKey          = "aa28cd19-b10a-41ff-981b-53c6bbf15ead";

            MockCommandRuntime mockCommandRuntime      = new MockCommandRuntime();
            Mock <ExpressRouteManagementClient> client = InitExpressRouteManagementClient();
            var dcMock = new Mock <IDedicatedCircuitOperations>();

            DedicatedCircuitGetResponse expected =
                new DedicatedCircuitGetResponse()
            {
                DedicatedCircuit = new AzureDedicatedCircuit()
                {
                    CircuitName         = circuitName,
                    Bandwidth           = bandwidth,
                    Location            = location,
                    ServiceProviderName = serviceProviderName,
                    ServiceKey          = serviceKey,
                    ServiceProviderProvisioningState = ProviderProvisioningState.NotProvisioned,
                    Status = DedicatedCircuitState.Enabled,
                },
                RequestId  = "",
                StatusCode = new HttpStatusCode()
            };
            var t = new Task <DedicatedCircuitGetResponse>(() => expected);

            t.Start();

            dcMock.Setup(f => f.NewAsync(It.Is <DedicatedCircuitNewParameters>(x => x.Bandwidth == bandwidth && x.CircuitName == circuitName && x.Location == location && x.ServiceProviderName == serviceProviderName), It.IsAny <CancellationToken>())).Returns((DedicatedCircuitNewParameters param, CancellationToken cancellation) => t);
            client.SetupGet(f => f.DedicatedCircuits).Returns(dcMock.Object);

            NewAzureDedicatedCircuitCommand cmdlet = new NewAzureDedicatedCircuitCommand()
            {
                CircuitName         = circuitName,
                Bandwidth           = bandwidth,
                Location            = location,
                ServiceProviderName = serviceProviderName,
                CommandRuntime      = mockCommandRuntime,
                ExpressRouteClient  = new ExpressRouteClient(client.Object)
            };

            cmdlet.ExecuteCmdlet();

            // Assert
            AzureDedicatedCircuit actual = mockCommandRuntime.OutputPipeline[0] as AzureDedicatedCircuit;

            Assert.Equal <string>(expected.DedicatedCircuit.CircuitName, actual.CircuitName);
            Assert.Equal <uint>(expected.DedicatedCircuit.Bandwidth, actual.Bandwidth);
            Assert.Equal <string>(expected.DedicatedCircuit.Location, actual.Location);
            Assert.Equal <string>(expected.DedicatedCircuit.ServiceProviderName, actual.ServiceProviderName);
            Assert.Equal(expected.DedicatedCircuit.ServiceProviderProvisioningState, actual.ServiceProviderProvisioningState);
            Assert.Equal(expected.DedicatedCircuit.Status, actual.Status);
            Assert.Equal <string>(expected.DedicatedCircuit.ServiceKey, actual.ServiceKey);
        }
        public void NewAzureDedicatedCircuitSuccessful()
        {
            // Setup

            string circuitName = "TestCircuit";
            uint bandwidth = 10;
            string serviceProviderName = "TestProvider";
            string location = "us-west";
            string serviceKey = "aa28cd19-b10a-41ff-981b-53c6bbf15ead";

            MockCommandRuntime mockCommandRuntime = new MockCommandRuntime();
            Mock<ExpressRouteManagementClient> client = InitExpressRouteManagementClient();
            var dcMock = new Mock<IDedicatedCircuitOperations>();

            DedicatedCircuitGetResponse expected =
                new DedicatedCircuitGetResponse()
                {
                    DedicatedCircuit = new AzureDedicatedCircuit()
                    {
                        CircuitName = circuitName,
                        Bandwidth = bandwidth,
                        Location = location,
                        ServiceProviderName = serviceProviderName,
                        ServiceKey = serviceKey,
                        ServiceProviderProvisioningState = ProviderProvisioningState.NotProvisioned,
                        Status = DedicatedCircuitState.Enabled,
                    },
                    RequestId = "",
                    StatusCode = new HttpStatusCode()
                };
            var t = new Task<DedicatedCircuitGetResponse>(() => expected);
            t.Start();

            dcMock.Setup(f => f.NewAsync(It.Is<DedicatedCircuitNewParameters>(x => x.Bandwidth == bandwidth && x.CircuitName == circuitName && x.Location == location && x.ServiceProviderName == serviceProviderName), It.IsAny<CancellationToken>())).Returns((DedicatedCircuitNewParameters param, CancellationToken cancellation) => t);
            client.SetupGet(f => f.DedicatedCircuit).Returns(dcMock.Object);

            NewAzureDedicatedCircuitCommand cmdlet = new NewAzureDedicatedCircuitCommand()
            {
                CircuitName = circuitName,
                Bandwidth = bandwidth,
                Location = location,
                ServiceProviderName = serviceProviderName,
                CommandRuntime = mockCommandRuntime,
                ExpressRouteClient = new ExpressRouteClient(client.Object)
            };

            cmdlet.ExecuteCmdlet();

            // Assert
            AzureDedicatedCircuit actual = mockCommandRuntime.OutputPipeline[0] as AzureDedicatedCircuit;
            Assert.AreEqual<string>(expected.DedicatedCircuit.CircuitName, actual.CircuitName);
            Assert.AreEqual<uint>(expected.DedicatedCircuit.Bandwidth, actual.Bandwidth);
            Assert.AreEqual<string>(expected.DedicatedCircuit.Location, actual.Location);
            Assert.AreEqual<string>(expected.DedicatedCircuit.ServiceProviderName, actual.ServiceProviderName);
            Assert.AreEqual(expected.DedicatedCircuit.ServiceProviderProvisioningState, actual.ServiceProviderProvisioningState);
            Assert.AreEqual(expected.DedicatedCircuit.Status, actual.Status);
            Assert.AreEqual<string>(expected.DedicatedCircuit.ServiceKey, actual.ServiceKey);
        }
        public void NewAzureDedicatedCircuitSuccessful()
        {
            // Setup

            string      circuitName         = "TestCircuit";
            uint        bandwidth           = 10;
            string      serviceProviderName = "TestProvider";
            string      location            = "us-west";
            string      serviceKey          = "aa28cd19-b10a-41ff-981b-53c6bbf15ead";
            BillingType billingType         = BillingType.MeteredData;
            CircuitSku  sku = CircuitSku.Premium;

            MockCommandRuntime mockCommandRuntime      = new MockCommandRuntime();
            Mock <ExpressRouteManagementClient> client = InitExpressRouteManagementClient();
            var dcMock = new Mock <IDedicatedCircuitOperations>();

            DedicatedCircuitGetResponse expected =
                new DedicatedCircuitGetResponse()
            {
                DedicatedCircuit = new AzureDedicatedCircuit()
                {
                    CircuitName         = circuitName,
                    Bandwidth           = bandwidth,
                    BillingType         = billingType.ToString(),
                    Location            = location,
                    ServiceProviderName = serviceProviderName,
                    ServiceKey          = serviceKey,
                    ServiceProviderProvisioningState = ProviderProvisioningState.NotProvisioned,
                    Status = DedicatedCircuitState.Enabled,
                    Sku    = sku
                },
                RequestId  = "",
                StatusCode = new HttpStatusCode()
            };
            var tGet = new Task <DedicatedCircuitGetResponse>(() => expected);

            tGet.Start();

            ExpressRouteOperationStatusResponse expectedStatus = new ExpressRouteOperationStatusResponse()
            {
                HttpStatusCode = HttpStatusCode.OK,
                Data           = serviceKey
            };

            var tNew = new Task <ExpressRouteOperationStatusResponse>(() => expectedStatus);

            tNew.Start();

            ExpressRouteOperationStatusResponse expectedUpdateStatus = new ExpressRouteOperationStatusResponse()
            {
                HttpStatusCode = HttpStatusCode.OK,
                Data           = serviceKey
            };

            var tUpdate = new Task <ExpressRouteOperationStatusResponse>(() => expectedUpdateStatus);

            tUpdate.Start();

            dcMock.Setup(f => f.NewAsync(It.Is <DedicatedCircuitNewParameters>(x => x.Bandwidth == bandwidth &&
                                                                               x.CircuitName == circuitName && x.Location == location && x.ServiceProviderName == serviceProviderName),
                                         It.IsAny <CancellationToken>())).Returns((DedicatedCircuitNewParameters param, CancellationToken cancellation) => tNew);

            dcMock.Setup(f => f.GetAsync(It.Is <string>(sKey => sKey == serviceKey), It.IsAny <CancellationToken>())).Returns((string sKey, CancellationToken cancellation) => tGet);

            dcMock.Setup(f => f.UpdateAsync(It.Is <string>(sKey => sKey == serviceKey),
                                            It.Is <DedicatedCircuitUpdateParameters>(y => y.Bandwidth == bandwidth.ToString() && y.BillingType == billingType && y.Sku == sku.ToString()),
                                            It.IsAny <CancellationToken>())).Returns((string sKey, DedicatedCircuitUpdateParameters updateParam,
                                                                                      CancellationToken cancellation) => tUpdate);
            client.SetupGet(f => f.DedicatedCircuits).Returns(dcMock.Object);

            NewAzureDedicatedCircuitCommand cmdlet = new NewAzureDedicatedCircuitCommand()
            {
                CircuitName         = circuitName,
                Bandwidth           = bandwidth,
                BillingType         = billingType,
                Location            = location,
                ServiceProviderName = serviceProviderName,
                Sku                = sku,
                CommandRuntime     = mockCommandRuntime,
                ExpressRouteClient = new ExpressRouteClient(client.Object)
            };

            cmdlet.ExecuteCmdlet();

            // Assert
            AzureDedicatedCircuit actual = mockCommandRuntime.OutputPipeline[0] as AzureDedicatedCircuit;

            Assert.Equal <string>(expected.DedicatedCircuit.CircuitName, actual.CircuitName);
            Assert.Equal <string>(expected.DedicatedCircuit.BillingType, actual.BillingType);
            Assert.Equal <uint>(expected.DedicatedCircuit.Bandwidth, actual.Bandwidth);
            Assert.Equal <string>(expected.DedicatedCircuit.Location, actual.Location);
            Assert.Equal <string>(expected.DedicatedCircuit.ServiceProviderName, actual.ServiceProviderName);
            Assert.Equal(expected.DedicatedCircuit.ServiceProviderProvisioningState, actual.ServiceProviderProvisioningState);
            Assert.Equal(expected.DedicatedCircuit.Status, actual.Status);
            Assert.Equal <string>(expected.DedicatedCircuit.ServiceKey, actual.ServiceKey);
            Assert.Equal <CircuitSku>(expected.DedicatedCircuit.Sku, actual.Sku);

            SetAzureDedicatedCircuitPropertiesCommand setCmdlet = new SetAzureDedicatedCircuitPropertiesCommand()
            {
                ServiceKey         = Guid.Parse(actual.ServiceKey),
                Bandwidth          = bandwidth,
                BillingType        = billingType,
                Sku                = sku,
                CommandRuntime     = mockCommandRuntime,
                ExpressRouteClient = new ExpressRouteClient(client.Object)
            };

            setCmdlet.ExecuteCmdlet();
            actual = mockCommandRuntime.OutputPipeline[0] as AzureDedicatedCircuit;
            Assert.Equal <string>(expected.DedicatedCircuit.CircuitName, actual.CircuitName);
            Assert.Equal <string>(expected.DedicatedCircuit.BillingType, actual.BillingType);
            Assert.Equal <uint>(expected.DedicatedCircuit.Bandwidth, actual.Bandwidth);
            Assert.Equal <string>(expected.DedicatedCircuit.Location, actual.Location);
            Assert.Equal <string>(expected.DedicatedCircuit.ServiceProviderName, actual.ServiceProviderName);
            Assert.Equal(expected.DedicatedCircuit.ServiceProviderProvisioningState, actual.ServiceProviderProvisioningState);
            Assert.Equal(expected.DedicatedCircuit.Status, actual.Status);
            Assert.Equal <string>(expected.DedicatedCircuit.ServiceKey, actual.ServiceKey);
            Assert.Equal <CircuitSku>(expected.DedicatedCircuit.Sku, actual.Sku);
        }