Exemple #1
0
        public void TestRevertServerResize()
        {
            IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);

            string serverName = UserComputeTests.UnitTestServerPrefix + Path.GetRandomFileName();

            Flavor flavor = UserComputeTests.ListAllFlavorsWithDetails(provider).OrderBy(i => i.RAMInMB).ThenBy(i => i.DiskSizeInGB).FirstOrDefault(i => !i.Id.Equals(_server.Flavor.Id, StringComparison.OrdinalIgnoreCase));

            if (flavor == null)
            {
                Assert.Inconclusive("Couldn't find a flavor to use for the test server.");
            }

            bool resized = provider.ResizeServer(_server.Id, serverName, flavor.Id);

            Assert.IsTrue(resized);
            Server resizedServer = provider.WaitForServerState(_server.Id, ServerState.VerifyResize, new[] { ServerState.Active, ServerState.Error });

            Assert.AreEqual(ServerState.Active, resizedServer.Status);
            _server = resizedServer;

            bool reverted = provider.RevertServerResize(resizedServer.Id);

            Assert.IsTrue(reverted);
            Server revertedServer = provider.WaitForServerActive(_server.Id);

            Assert.AreEqual(ServerState.Active, revertedServer.Status);
            _server = revertedServer;
        }
Exemple #2
0
        public void TestRescueServer()
        {
            IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);

            string rescueResult = provider.RescueServer(_server.Id);

            Assert.IsFalse(string.IsNullOrEmpty(rescueResult));
            Server rescueServer = provider.WaitForServerState(_server.Id, ServerState.Rescue, new[] { ServerState.Error });

            Assert.AreEqual(ServerState.Rescue, rescueServer.Status);

            bool unrescueResult = provider.UnRescueServer(_server.Id);

            Assert.IsTrue(unrescueResult);
            Server unrescueServer = provider.WaitForServerActive(_server.Id);

            Assert.AreEqual(ServerState.Active, unrescueServer.Status);
        }
        public void Should_Wait_For_Server_To_Go_Into_Rescue_Status()
        {
            Assert.IsFalse(string.IsNullOrWhiteSpace(_rescueAdminPass));

            var provider = new CloudServersProvider(_testIdentity);
            var details = provider.WaitForServerState(_testServer.Id, ServerState.RESCUE, new[] { ServerState.ERROR, ServerState.UNKNOWN, ServerState.SUSPENDED });

            Assert.IsNotNull(details);
        }
        public void Should_Wait_For_Server_To_Go_Into_Confirm_Resize_Status()
        {
            Assert.IsTrue(_confirmResizeSuccess);

            var provider = new CloudServersProvider(_testIdentity);
            var details = provider.WaitForServerState(_testServer.Id, ServerState.VERIFY_RESIZE, new[] { ServerState.ERROR, ServerState.UNKNOWN, ServerState.SUSPENDED });

            Assert.IsNotNull(details);
        }
        public void Should_Wait_For_Server_To_Go_Into_Rebuild_Status()
        {
            Assert.IsNotNull(_rebuildServer);

            var provider = new CloudServersProvider(_testIdentity);
            var details = provider.WaitForServerState(_testServer.Id, ServerState.REBUILD, new[] { ServerState.ERROR, ServerState.UNKNOWN, ServerState.SUSPENDED });

            Assert.IsNotNull(details);
            Assert.AreEqual(_testServer.Id, _rebuildServer.Id);
        }
        public void Should_Wait_Until_Server_Goes_Into_Hard_Reboot_State()
        {
            Assert.IsTrue(_rebootSuccess); // If the reboot was not successful in the previous test, then fail this one too.

            var provider = new CloudServersProvider(_testIdentity);

            var details = provider.WaitForServerState(_testServer.Id, ServerState.HARD_REBOOT, new[] { ServerState.ERROR, ServerState.UNKNOWN, ServerState.SUSPENDED });

            Assert.IsNotNull(details);
        }
        public void TestRevertServerResize()
        {
            IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);

            string serverName = UserComputeTests.UnitTestServerPrefix + Path.GetRandomFileName();

            Flavor flavor = UserComputeTests.ListAllFlavorsWithDetails(provider).OrderBy(i => i.RAMInMB).ThenBy(i => i.DiskSizeInGB).FirstOrDefault(i => !i.Id.Equals(_server.Flavor.Id, StringComparison.OrdinalIgnoreCase));
            if (flavor == null)
                Assert.Inconclusive("Couldn't find a flavor to use for the test server.");

            bool resized = provider.ResizeServer(_server.Id, serverName, flavor.Id);
            Assert.IsTrue(resized);
            Server resizedServer = provider.WaitForServerState(_server.Id, ServerState.VerifyResize, new[] { ServerState.Error, ServerState.Unknown, ServerState.Suspended });
            Assert.AreEqual(ServerState.VerifyResize, resizedServer.Status);
            _server = resizedServer;

            bool reverted = provider.RevertServerResize(resizedServer.Id);
            Assert.IsTrue(reverted);
            Server revertedServer = provider.WaitForServerActive(_server.Id);
            Assert.AreEqual(ServerState.Active, revertedServer.Status);
            _server = revertedServer;
        }
        public void TestRescueServer()
        {
            IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);

            string rescueResult = provider.RescueServer(_server.Id);
            Assert.IsFalse(string.IsNullOrEmpty(rescueResult));
            Server rescueServer = provider.WaitForServerState(_server.Id, ServerState.Rescue, new[] { ServerState.Error });
            Assert.AreEqual(ServerState.Rescue, rescueServer.Status);

            bool unrescueResult = provider.UnRescueServer(_server.Id);
            Assert.IsTrue(unrescueResult);
            Server unrescueServer = provider.WaitForServerActive(_server.Id);
            Assert.AreEqual(ServerState.Active, unrescueServer.Status);
        }