/// <summary>
        /// Test Command: ReadChassisLogWithTimestamp. Test case verifies:
        /// The command returns completion code success for WcsAdmin;
        /// Bad Request for WcsOperator and WcsUser
        /// </summary>
        /// <returns>True if all check-points pass; false, otherwise.</returns>
        // [TFS WorkItem:2577] ReadChassisLogWithTimestamp: Verify all users from are able to execute the command
        public bool ReadChassisLogWithTimestampByAllUsers()
        {
            CmTestLog.Start();

            bool testPassed = true;

            // Loop through different user types and ReadChassisLogWithTimestamp
            foreach (WCSSecurityRole roleId in Enum.GetValues(typeof(WCSSecurityRole)))
            {
                ChassisLogResponse chassisLog;
                // Use different user context
                this.TestChannelContext = this.ListTestChannelContexts[(int)roleId];

                CmTestLog.Info(string.Format("Trying to ReadChassisLogWithTimestamp with user type {0} ", roleId.ToString()));

                chassisLog = this.TestChannelContext.ReadChassisLogWithTimestamp(DateTime.MinValue, DateTime.Now);

                if (chassisLog.completionCode != CompletionCode.Success && (roleId == WCSSecurityRole.WcsCmAdmin || roleId == WCSSecurityRole.WcsCmOperator || roleId == WCSSecurityRole.WcsCmUser))
                {
                    CmTestLog.Failure(string.Format("Cannot Get Read ChassisLogs WithTimestamp With User {0}", roleId.ToString()));
                    CmTestLog.End(false);
                    return(false);
                }
                else
                {
                    testPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, chassisLog.completionCode, "Received ReadChassisLogWithTimestamp for user " + roleId.ToString());
                }
            }

            CmTestLog.End(testPassed);
            return(testPassed);
        }
Ejemplo n.º 2
0
        /// <summary>
        ///     SetACSocketPowerStateOff: Verify that only Operator and Admin can execute the command
        /// </summary>
        /// <returns></returns>
        protected bool AcSocketPowerSetByAdminOperatorTest()
        {
            CmTestLog.Start();
            bool testPassed = true;

            string     failureMessage = string.Empty;
            const uint NumACSocket    = CmConstants.NumPowerSwitches;

            foreach (WCSSecurityRole roleId in Enum.GetValues(typeof(WCSSecurityRole)))
            {
                try
                {
                    this.AcSocketSetGetValidation(ref testPassed, ref failureMessage, NumACSocket, roleId);
                }
                catch (Exception e)
                {
                    // Check error is due to permission HTTP 401 unauthorize
                    if (!e.Message.Contains("401") && roleId == WCSSecurityRole.WcsCmUser)
                    {
                        // Test failed, http response should contain http 401 error
                        CmTestLog.Failure("We are expecting 401 error, but we received 400 instead.");
                    }
                }
            }

            Console.WriteLine("\n++++++++++++++++++++++++++++++++");
            failureMessage = "!!!!!!!!! Successfully finished execution of ACSocketPowerTests.";
            Console.WriteLine(failureMessage);

            CmTestLog.End(testPassed);
            return(testPassed);
        }
        /// <summary>
        /// Test Command: ReadChassisLogWithTimestamp. The test case verifies:
        /// The command returns completion code success;
        /// Verifies all the entries with in the time stamp
        /// </summary>
        /// <returns>True if all check-points pass; false, otherwise.</returns>
        public bool ReadChassisLogWithTimestamp()
        {
            CmTestLog.Start();
            bool testPassed = true;

            ChassisLogResponse cmLogReponse         = null;
            ChassisLogResponse CMLogReponseWithTime = null;

            CmTestLog.Info("!!!!!!!!! Starting execution of ReadChassisLogWithTimestampTest !!!!!!!!!");

            cmLogReponse = this.Channel.ReadChassisLog();
            testPassed  &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, cmLogReponse.completionCode, "Received for read chassis log");

            // Make sure log entries should not  be more than 50
            testPassed &= ChassisManagerTestHelper.IsTrue(cmLogReponse.logEntries.Count <= CmConstants.LogEntries, string.Format("Received {0} log entries", cmLogReponse.logEntries.Count));

            DateTime invalidStart = DateTime.Now.AddDays(1);
            DateTime invalidEnd   = DateTime.Now.AddDays(2);

            CMLogReponseWithTime = this.Channel.ReadChassisLogWithTimestamp(invalidStart, invalidEnd);
            testPassed          &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, CMLogReponseWithTime.completionCode, "Received success for ReadChassisLogWithTimestamp");
            testPassed          &= ChassisManagerTestHelper.IsTrue(CMLogReponseWithTime.logEntries.Count == 0, "Received zero entries for invalid timestamp");

            //need to clear the chassis log so the response is not too big
            ChassisResponse response = this.Channel.ClearChassisLog();

            //Add couple more calls
            this.Channel.SetChassisAttentionLEDOn();
            this.Channel.SetChassisAttentionLEDOff();

            cmLogReponse = this.Channel.ReadChassisLog();

            DateTime start = DateTime.Now.AddDays(-1);
            DateTime end   = DateTime.Now.AddDays(1);

            CMLogReponseWithTime = this.Channel.ReadChassisLogWithTimestamp(start, end);

            testPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, CMLogReponseWithTime.completionCode, "Received success for ReadChassisLogWithTimestamp");

            testPassed &= ChassisManagerTestHelper.IsTrue(cmLogReponse.logEntries[1].eventTime > start, "Log entires start time");
            testPassed &= ChassisManagerTestHelper.IsTrue(cmLogReponse.logEntries[cmLogReponse.logEntries.Count - 1].eventTime < end, "Log entires end time");

            int logSize = CMLogReponseWithTime.logEntries.Count;

            if (!CMLogReponseWithTime.logEntries[logSize - 1].eventDescription.Contains("SetChassisAttentionLEDOn"))
            {
                CmTestLog.Failure("!!!Failed to read the CM logs with a time range.");
                return(false);
            }
            //This will require that the CM doesn't receive any other user commands.
            if (!CMLogReponseWithTime.logEntries[0].eventDescription.Contains("ReadChassisLog"))
            {
                CmTestLog.Failure("!!!Failed to read the CM logs with a time range.");
                return(false);
            }

            CmTestLog.End(testPassed);
            return(testPassed);
        }
Ejemplo n.º 4
0
        /// <summary>
        ///     GetACSocketPowerState: Verify that all users can execute the command
        /// </summary>
        /// <returns></returns>
        protected bool AcSocketPowerGetByAllUserTest()
        {
            CmTestLog.Start();
            bool testPassed = true;

            string failureMessage;

            ChassisResponse       acSocketResponse = null;
            ACSocketStateResponse acSocketPower    = null;
            uint numAcSocket = CmConstants.NumPowerSwitches;

            Console.WriteLine("!!!!!!!!! Started execution of ACSocketPowerTest.");

            foreach (WCSSecurityRole roleId in Enum.GetValues(typeof(WCSSecurityRole)))
            {
                //Change test connection to different role
                this.TestChannelContext = this.ListTestChannelContexts[(int)roleId];

                for (int testedAcSocket = 1; testedAcSocket <= numAcSocket; testedAcSocket++)
                {
                    // Turn off ACSocket Power state
                    acSocketResponse = this.Channel.SetACSocketPowerStateOff(testedAcSocket);

                    if (acSocketResponse.completionCode == CompletionCode.Success)
                    {
                        // Check to see if socket power state is return correctly
                        acSocketPower = this.TestChannelContext.GetACSocketPowerState(testedAcSocket);
                        if (acSocketPower.powerState != PowerState.OFF)
                        {
                            failureMessage = string.Format("!!!Failed to get power state for AC socket#{0}", testedAcSocket);
                            CmTestLog.Failure(failureMessage);
                            testPassed = false;
                        }
                    }

                    // Turn on ACSocket Power state
                    acSocketResponse = this.Channel.SetACSocketPowerStateOn(testedAcSocket);

                    if (acSocketResponse.completionCode == CompletionCode.Success)
                    {
                        // Check to see if socket power state is return correctly
                        acSocketPower = this.TestChannelContext.GetACSocketPowerState(testedAcSocket);
                        if (acSocketPower.powerState != PowerState.ON)
                        {
                            failureMessage = string.Format("!!!Failed to get power state for AC socket#{0}", testedAcSocket);
                            CmTestLog.Failure(failureMessage);
                            testPassed = false;
                        }
                    }
                }
            }

            failureMessage = "!!!!!!!!! Successfully finished execution of ACSocketPowerTests.";
            Console.WriteLine(failureMessage);

            CmTestLog.End(testPassed);
            return(testPassed);
        }
Ejemplo n.º 5
0
 /// <summary>
 /// This method returns list of empty slot for CM
 /// </summary>
 /// <returns>Returns list of empty slots if CM have any empty slots; return null otherwise.</returns>
 protected int[] GetEmptyLocations()
 {
     int[] emptyLocations;
     if (this.GetBladeLocations(blade => blade.bladeType.Equals(CmConstants.EmptyBladeType), out emptyLocations))
     {
         return(emptyLocations);
     }
     CmTestLog.End(false, "Did NOT find empty locations");
     return(null);
 }
Ejemplo n.º 6
0
 /// <summary>
 /// This method returns list of JBOD slot for CM
 /// </summary>
 /// <returns>Returns list of JBOD if CM have any; return null otherwise.</returns>
 protected int[] GetJbodLocations()
 {
     int[] jbodLocations;
     if (this.GetBladeLocations(blade => blade.bladeType.Equals(CmConstants.JbodBladeType), out jbodLocations))
     {
         return(jbodLocations);
     }
     CmTestLog.End(false, "Did NOT find server locations");
     return(null);
 }
        /// <summary>
        /// Test Command: ClearChassisLog
        /// Test case verifies: Completion code success
        /// Verifies Log entries count after clear chassis log and read chassislog
        /// </summary>
        /// <returns>True if all check-points pass; false, otherwise.</returns>
        public bool ClearChassisLog()
        {
            CmTestLog.Start();
            bool testPassed = true;
            ChassisLogResponse cmLogsResponse;
            ChassisResponse    cmResponse;

            CmTestLog.Info(" !!!!!! Started running of clearchassislogtest !!!!!! ");

            cmResponse  = this.Channel.ClearChassisLog();
            testPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, cmResponse.completionCode, "Received for clear chassis log");

            CmTestLog.Info("Verifying log entries after clear the chassis logs");
            cmLogsResponse = this.Channel.ReadChassisLog();
            testPassed    &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, cmResponse.completionCode, "Received for read chassis log");

            testPassed &= ChassisManagerTestHelper.AreEqual(CmConstants.LogCount, cmLogsResponse.logEntries.Count, "Received for log entries count");

            CmTestLog.End(testPassed);
            return(testPassed);
        }
        /// <summary>
        /// Test Command: ReadBladeLogWithTimestamp. The test case verifies:
        /// The command returns completion code success;
        /// The command succeeds even after all logs are cleared.
        /// </summary>
        /// <returns>True if all check-points pass; false, otherwise.</returns>
        public bool ReadBladeLogWithTimestampTest()
        {
            CmTestLog.Start();

            // get all server blade locations
            int[] serverLocations;
            if (!GetBladeLocations(blade => blade.bladeType.Equals(CmConstants.ServerBladeType),
                                   out serverLocations) || serverLocations.Length == 0)
            {
                CmTestLog.Failure("Cannot find any server blade");
                CmTestLog.End(false);
                return(false);
            }
            // pick up a random server blade
            var bladeId = serverLocations.RandomOrDefault();

            CmTestLog.Info(string.Format("Pick up a random server blade# {0} for test", bladeId));

            bool            testPassed = true;
            ChassisResponse response;

            // read logs from the blade
            CmTestLog.Info("Trying to read blade log with timestamp from Blade# " + bladeId);
            response    = this.Channel.ReadBladeLogWithTimestamp(bladeId, DateTime.MinValue, DateTime.Now);
            testPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, response.completionCode, "Logs read from Blade# " + bladeId);

            // clear the logs and read again
            CmTestLog.Info("Trying to clear the logs on Blade# " + bladeId);
            response    = this.Channel.ClearBladeLog(bladeId);
            testPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, response.completionCode, "Logs cleared on Blade# " + bladeId);

            CmTestLog.Info("Trying to read logs again from Blade# " + bladeId);
            response    = this.Channel.ReadBladeLogWithTimestamp(bladeId, DateTime.MinValue, DateTime.Now);
            testPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, response.completionCode, "Logs read from Blade# " + bladeId);

            // end of the test
            CmTestLog.End(testPassed);
            return(testPassed);
        }
        /// <summary>
        /// Test Command: ClearChassisLog. Test case verifies:
        /// The command returns completion code success for WcsAdmin;
        /// Bad Request for WcsOperator and WcsUser
        /// </summary>
        /// <returns>True if all check-points pass; false, otherwise.</returns>
        // [TFS WorkItem:2585] ClearChassisLog: Verify ONLY users from WcsCmAdmin are able to execute the command
        public bool ClearChassisLogByAllUsers()
        {
            CmTestLog.Start();

            bool testPassed = true;

            // Loop through different user types and ReadChassisLogWithTimestamp
            foreach (WCSSecurityRole roleId in Enum.GetValues(typeof(WCSSecurityRole)))
            {
                try
                {
                    // Use different user context
                    this.TestChannelContext = this.ListTestChannelContexts[(int)roleId];

                    CmTestLog.Info(string.Format("Trying to ClearChassisLog with user type {0} ", roleId.ToString()));

                    ChassisResponse clearChassisLog = this.TestChannelContext.ClearChassisLog();

                    testPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, clearChassisLog.completionCode, "Received ClearChassisLog for user " + roleId.ToString());
                }
                catch (Exception ex)
                {
                    // Check error is due to permission HTTP 400 bad request
                    if (ex.Message.Contains("400") && roleId == WCSSecurityRole.WcsCmUser)
                    {
                        ChassisManagerTestHelper.IsTrue(true, "ClearChassisLog returned Bad Request for user " + roleId.ToString());
                    }
                    else
                    {
                        ChassisManagerTestHelper.IsTrue(false, "Exception: " + ex.Message);
                        testPassed = false;
                    }
                }
            }

            CmTestLog.End(testPassed);
            return(testPassed);
        }
        /// <summary>
        /// Test Command: ReadChassisLog
        /// The test case verifies: All users can execute command
        /// </summary>
        /// <returns>True if all check-points pass; false, otherwise.</returns>
        public bool ReadChassisLogTest()
        {
            CmTestLog.Start();
            bool   allPassed  = true;
            string currentApi = "ReadChassisLog";

            try
            {
                // Verify all users can execute command : WorkItem(2580)
                bool userPassed;

                foreach (WCSSecurityRole TestUser in Enum.GetValues(typeof(WCSSecurityRole)))
                {
                    CmTestLog.Info("Calling " + currentApi + " for user type " + TestUser);
                    userPassed = true;

                    VerifyReadChassisLog(ref userPassed, TestUser);

                    ChassisManagerTestHelper.IsTrue(userPassed,
                                                    currentApi + ": Command executed for user " + TestUser);

                    allPassed &= userPassed;
                }
                ChassisManagerTestHelper.IsTrue(allPassed,
                                                currentApi + ": All users can execute the command");
            }
            catch (Exception ex)
            {
                ChassisManagerTestHelper.IsTrue(false, ex.Message);
                ChassisManagerTestHelper.IsTrue(StartStopCmService("start"),
                                                currentApi + ": Chassis Manager service started");
                allPassed = false;
            }

            CmTestLog.End(allPassed);
            return(allPassed);
        }
        /// <summary>
        ///     Basic validation test to set NextBoot test
        /// </summary>
        protected Boolean SetNextBootTest()
        {
            CmTestLog.Start();

            bool testPassed = true;
            bool isServer   = false;

            int    bladeIndex = 1;
            string failureMessage;

            EmptyLocations = GetEmptyLocations();
            JbodLocations  = GetJbodLocations();

            CmTestLog.Info("!!!!!!!!! Starting execution of SetNextBootTest.");

            //Make sure blade is reacheable
            //Loop through servers listing and find first Blad to test
            while (!isServer && bladeIndex <= CmConstants.Population)
            {
                if (!JbodLocations.Contains(bladeIndex) && !EmptyLocations.Contains(bladeIndex))
                {
                    isServer = true;
                }
                else
                {
                    bladeIndex++;
                }
            }

            if (bladeIndex > CmConstants.Population)
            {
                failureMessage = "!!!Failed to find a server blade to run the test.";
                CmTestLog.Failure(failureMessage);
                return(false);
            }

            Channel.SetPowerOn(bladeIndex);
            Thread.Sleep(50000);

            BootResponse bBootType;

            int index = 1;

            foreach (BladeBootType testedBootType in Enum.GetValues(typeof(BladeBootType)))
            {
                //Doing the same setting twice to make sure we are handling this properly.
                if (testedBootType.ToString() != BladeBootType.Unknown.ToString())
                {
                    //set to persistent.
                    bBootType = Channel.SetNextBoot(bladeIndex, testedBootType, false, false, 0);
                    if (bBootType.completionCode != CompletionCode.Success)
                    {
                        failureMessage = string.Format("!!!Failed to set non persistant boot type to: {0}",
                                                       testedBootType);
                        CmTestLog.Failure(failureMessage);
                        testPassed = false;
                    }

                    bBootType = Channel.GetNextBoot(bladeIndex);
                    if (testedBootType.ToString() != bBootType.nextBoot.ToString())
                    {
                        failureMessage = "!!!The Non persistent boot type did not match what it was set to.";
                        CmTestLog.Failure(failureMessage);
                        testPassed = false;
                    }

                    //set to non persistent.
                    bBootType = Channel.SetNextBoot(bladeIndex, testedBootType, false, true, 1);
                    if (bBootType.completionCode != CompletionCode.Success)
                    {
                        failureMessage = string.Format("!!!Failed to set Persistent boot type to: {0}", testedBootType);
                        CmTestLog.Failure(failureMessage);
                        testPassed = false;
                    }

                    //Make sure if no restart happens it keeps its value.
                    bBootType = Channel.GetNextBoot(bladeIndex);
                    if (testedBootType.ToString() != bBootType.nextBoot.ToString())
                    {
                        failureMessage = "!!!The boot type did not match what it was set to.";
                        CmTestLog.Failure(failureMessage);
                        testPassed = false;
                    }
                    //Make sure it loses its value after restart
                    Channel.SetBladeActivePowerCycle(bladeIndex, 0);
                    Thread.Sleep(60000);
                    bBootType = Channel.GetNextBoot(bladeIndex);
                    if (testedBootType.ToString() != BladeBootType.ForcePxe.ToString() &&
                        testedBootType.ToString() != bBootType.nextBoot.ToString())
                    {
                        failureMessage =
                            string.Format(
                                "!!!The boot type did not match what it was set to before power cycle. {0} vs {1} this is round# {2}",
                                testedBootType, bBootType.nextBoot, index);
                        CmTestLog.Failure(failureMessage);
                        testPassed = false;
                    }
                }
            }
            Channel.SetNextBoot(bladeIndex, BladeBootType.NoOverride, false, true, 0);

            CmTestLog.Info("!!!!!!!!! Successfully finished execution of SetNextBoot tests.");

            // end of the test
            CmTestLog.End(testPassed);

            return(testPassed);
        }
        /// <summary>
        ///     Test Command: SetNextBoot, GetNextBoot. The test case verifies:
        ///     The command returns a success completion code on server blades;
        ///     The command works with all blade types (except unknown type);
        ///     When set to non-persistent, the blade will lose its next boot value after restart.
        /// </summary>
        /// <returns>True if all check-points pass; false, otherwise.</returns>
        public bool SetGetNextBootTest()
        {
            CmTestLog.Start();

            // get all server blade locations
            int[] serverLocations;
            if (!GetBladeLocations(blade => blade.bladeType.Equals(CmConstants.ServerBladeType),
                                   out serverLocations) || serverLocations.Length == 0)
            {
                CmTestLog.Failure("Cannot find any server blade");
                CmTestLog.End(false);
                return(false);
            }
            // pick up a random server blade
            int bladeId = serverLocations.RandomOrDefault();

            CmTestLog.Info(string.Format("Pick up a random server blade# {0} for test", bladeId));

            // make sure the blade is powered on
            if (!SetPowerState(PowerState.ON, bladeId))
            {
                CmTestLog.Failure("Cannot power on Blade# " + bladeId);
                CmTestLog.End(false);
                return(false);
            }

            bool allPassed = true;

            foreach (BladeBootType bootType in Enum.GetValues(typeof(BladeBootType)))
            {
                if (bootType == BladeBootType.Unknown)
                {
                    continue;
                }

                //// set next boot to persistent
                CmTestLog.Info(string.Format("Trying to set next boot to Type {0} with persistent", bootType));
                BootResponse response = Channel.SetNextBoot(bladeId, bootType, false, true, 0);
                allPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, response.completionCode,
                                                               "Set persistent boot type");
                // get next boot and verify
                CmTestLog.Info("Trying to get the next boot");
                response   = Channel.GetNextBoot(bladeId);
                allPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success,
                                                               response.completionCode, "Get next boot value");
                allPassed &= ChassisManagerTestHelper.AreEqual(bootType, response.nextBoot,
                                                               "The boot type matches what it was set to");

                //// set to non persistent
                CmTestLog.Info(string.Format("Trying to set next boot to Type {0} with non-persistent", bootType));
                response   = Channel.SetNextBoot(bladeId, bootType, false, false, 1);
                allPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, response.completionCode,
                                                               "Set non-persistent boot type");
                // get next boot and verify
                CmTestLog.Info("Trying to get the next boot");
                response   = Channel.GetNextBoot(bladeId);
                allPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success,
                                                               response.completionCode, "Get next boot value");
                allPassed &= ChassisManagerTestHelper.AreEqual(bootType, response.nextBoot,
                                                               "The boot type matches what it was set to");
                // make sure it loses its value after restart
                if (!(bootType == BladeBootType.ForcePxe || bootType == BladeBootType.NoOverride))
                {
                    CmTestLog.Info("Trying to restart the blade and get next boot value again");
                    Channel.SetBladeActivePowerCycle(bladeId, 0);
                    Thread.Sleep(TimeSpan.FromMinutes(1));
                    response   = Channel.GetNextBoot(bladeId);
                    allPassed &= ChassisManagerTestHelper.IsTrue(bootType == response.nextBoot,
                                                                 "The blade loses its next boot value after power cycle");
                }
            }

            // end of the test
            CmTestLog.End(allPassed);
            return(allPassed);
        }
        /// <summary>
        ///     Basic validation test to set NextBoot test
        /// </summary>
        protected Boolean SetNextBootToJbodTest()
        {
            CmTestLog.Start();

            bool testPassed = true;

            bool   isJBodServer = false;
            int    bladeIndex   = 1;
            string failureMessage;

            EmptyLocations = GetEmptyLocations();
            JbodLocations  = GetJbodLocations();

            CmTestLog.Info("!!!!!!!!! Starting execution of SetNextBootTest.");

            //Find first Jbod Server
            while (!isJBodServer && bladeIndex <= CmConstants.Population)
            {
                if (JbodLocations.Contains(bladeIndex))
                {
                    isJBodServer = true;
                }
                else
                {
                    bladeIndex++;
                }
            }

            if (bladeIndex > CmConstants.Population)
            {
                failureMessage = "!!!Failed to find a server blade to run the test.";
                CmTestLog.Failure(failureMessage);
                return(false);
            }

            Channel.SetPowerOn(bladeIndex);
            Thread.Sleep(50000);

            BootResponse bBootType;

            foreach (BladeBootType testedBootType in Enum.GetValues(typeof(BladeBootType)))
            {
                //Doing the same setting twice to make sure we are handling this properly.
                if (testedBootType.ToString() != BladeBootType.Unknown.ToString())
                {
                    //set to persistent.
                    bBootType = Channel.SetNextBoot(bladeIndex, testedBootType, false, false, 0);
                    if (bBootType.completionCode == CompletionCode.Success &&
                        bBootType.completionCode != CompletionCode.CommandNotValidForBlade)
                    {
                        failureMessage = string.Format("Test failed, successfully set nextboot to JBOD type to: {0}",
                                                       testedBootType);
                        CmTestLog.Failure(failureMessage);
                        testPassed = false;
                    }

                    bBootType = Channel.GetNextBoot(bladeIndex);
                    if (bBootType.completionCode == CompletionCode.Success &&
                        bBootType.completionCode != CompletionCode.CommandNotValidForBlade)
                    {
                        failureMessage = string.Format("Test failed, successfully GET nextboot to JBOD type to: {0}",
                                                       testedBootType);
                        CmTestLog.Failure(failureMessage);
                        testPassed = false;
                    }
                }
            }

            // end of the test
            CmTestLog.End(testPassed);

            return(testPassed);
        }
        /// <summary>
        ///     Basic validation test to set NextBoot test
        /// </summary>
        protected Boolean SetNextBootByAllUserTest()
        {
            CmTestLog.Start();

            bool testPassed = true;
            bool isServer   = false;

            int    bladeIndex     = 1;
            string failureMessage = string.Empty;

            EmptyLocations = GetEmptyLocations();
            JbodLocations  = GetJbodLocations();

            CmTestLog.Info("!!!!!!!!! Starting execution of SetNextBootTest.");

            //Make sure blade is reacheable
            //Loop through servers listing and find first Blad to test
            while (!isServer && bladeIndex <= CmConstants.Population)
            {
                if (!JbodLocations.Contains(bladeIndex) && !EmptyLocations.Contains(bladeIndex))
                {
                    isServer = true;
                }
                else
                {
                    bladeIndex++;
                }
            }

            if (bladeIndex > CmConstants.Population)
            {
                failureMessage = "!!!Failed to find a server blade to run the test.";
                CmTestLog.Failure(failureMessage);
                return(false);
            }

            Channel.SetPowerOn(bladeIndex);
            Thread.Sleep(50000);


            int index = 1;

            foreach (WCSSecurityRole roleId in Enum.GetValues(typeof(WCSSecurityRole)))
            {
                try
                {
                    if (!GetSetNextBoots(testPassed, bladeIndex, failureMessage, index, roleId))
                    {
                        failureMessage = string.Format("Failed to set Persistent boot type by user type: {0}", roleId);
                        CmTestLog.Failure(failureMessage);
                        testPassed = false;
                        break;
                    }
                }
                catch (Exception e)
                {
                    // Check if we got 401 error
                    // Check error is due to permission HTTP 401 unauthorize
                    if (!e.Message.Contains("401"))
                    {
                        // Test failed, http response should contain http 401 error
                        CmTestLog.Failure("We are expecting 401 error, but we received 400 instead.");
                    }
                }
            }


            CmTestLog.Info("!!!!!!!!! Successfully finished execution of SetNextBoot tests.");

            // end of the test
            CmTestLog.End(testPassed);

            return(testPassed);
        }
        /// <summary>
        /// Test: User Logs
        /// The test case verifies:
        /// User Log exists
        /// </summary>
        /// <returns>True if all check-points pass; false, otherwise.</returns>
        public bool UserLogsTest()
        {
            CmTestLog.Start();
            bool   allPassed   = true;
            string currentTest = "UserLogs";

            try
            {
                string logParentDirectory = @"\\" + defaultCMName + @"\c$\";
                bool   foundUserLog       = false;

                IntPtr token = IntPtr.Zero;

                // Impersonate remote user
                bool successLogon = LogonUser(defaultAdminUserName, defaultCMName, defaultAdminPassword,
                                              (int)DwLogonType.NewCredentials, (int)DwLogonProvider.WinNT50, ref token);

                if (successLogon)
                {
                    using (WindowsImpersonationContext context = WindowsIdentity.Impersonate(token))
                    {
                        // Verify presence of User Log : WorkItem(2271)
                        if (!Directory.Exists(logParentDirectory))
                        {
                            CmTestLog.Failure(currentTest + ": Directory to User Log files does not exist");
                            return(false);
                        }

                        foreach (string filePath in Directory.GetFiles(logParentDirectory))
                        {
                            Match fileMatch = Regex.Match(filePath, @"ChassisManagerUserLog0[01]\.svclog");

                            if (fileMatch.Success)
                            {
                                CmTestLog.Success(currentTest + ": Verified presence of User Log " + filePath);
                                foundUserLog = true;
                                break;
                            }
                        }

                        allPassed &= foundUserLog;

                        // Revert back to original user
                        context.Undo();
                    }
                }
                else
                {
                    CmTestLog.Failure("UserLogon: User failed to be created");
                    return(false);
                }
            }
            catch (Exception ex)
            {
                ChassisManagerTestHelper.IsTrue(false, "Exception: " + ex.Message);
                allPassed = false;
            }

            CmTestLog.End(allPassed);
            return(allPassed);
        }
Ejemplo n.º 16
0
        /// <summary>
        ///     Basic functional validation test for AC SocketPower
        /// </summary>
        /// <returns></returns>
        protected bool AcSocketPowerTest()
        {
            CmTestLog.Start();
            bool testPassed = true;

            string failureMessage;

            ChassisResponse       acSocketResponse = null;
            ACSocketStateResponse acSocketPower    = null;
            uint NumACSocket = CmConstants.NumPowerSwitches;

            Console.WriteLine("!!!!!!!!! Started execution of ACSocketPowerTest.");

            for (int testedAcSocket = 1; testedAcSocket <= NumACSocket; testedAcSocket++)
            {
                acSocketResponse = this.Channel.SetACSocketPowerStateOff(testedAcSocket);
                if (acSocketResponse.completionCode != CompletionCode.Success)
                {
                    failureMessage = string.Format("!!!Failed to power off from unknown state for AC socket#{0}", testedAcSocket);
                    CmTestLog.Failure(failureMessage);
                    testPassed = false;
                }

                acSocketPower = this.Channel.GetACSocketPowerState(testedAcSocket);
                if (acSocketPower.powerState != PowerState.OFF)
                {
                    failureMessage = string.Format("!!!Failed to get power state for AC socket#{0}", testedAcSocket);
                    CmTestLog.Failure(failureMessage);
                    testPassed = false;
                }

                acSocketResponse = this.Channel.SetACSocketPowerStateOff(testedAcSocket);
                if (acSocketResponse.completionCode != CompletionCode.Success)
                {
                    failureMessage = string.Format("!!!Failed to power off AC socket when it is already off for socket#{0}", testedAcSocket);
                    CmTestLog.Failure(failureMessage);
                    testPassed = false;
                }

                acSocketPower = this.Channel.GetACSocketPowerState(testedAcSocket);
                if (acSocketPower.powerState != PowerState.OFF)
                {
                    failureMessage = string.Format("!!!Failed to get power state for AC socket#{0}", testedAcSocket);
                    CmTestLog.Failure(failureMessage);
                    testPassed = false;
                }

                acSocketResponse = this.Channel.SetACSocketPowerStateOn(testedAcSocket);
                if (acSocketResponse.completionCode != CompletionCode.Success)
                {
                    failureMessage = string.Format("!!!Failed to power ON AC socket#{0}", testedAcSocket);
                    CmTestLog.Failure(failureMessage);
                    testPassed = false;
                }

                acSocketPower = this.Channel.GetACSocketPowerState(testedAcSocket);
                if (acSocketPower.powerState != PowerState.ON)
                {
                    failureMessage = string.Format("!!!Failed to get power state for AC socket#{0}", testedAcSocket);
                    CmTestLog.Failure(failureMessage);
                    testPassed = false;
                }

                acSocketResponse = this.Channel.SetACSocketPowerStateOn(testedAcSocket);
                if (acSocketResponse.completionCode != CompletionCode.Success)
                {
                    failureMessage = string.Format("!!!Failed to power ON AC socket when it is already ON for AC Socket#{0}", testedAcSocket);
                    CmTestLog.Failure(failureMessage);
                    testPassed = false;
                }

                acSocketResponse = this.Channel.SetACSocketPowerStateOff(testedAcSocket);
                if (acSocketResponse.completionCode != CompletionCode.Success)
                {
                    failureMessage = string.Format("!!!Failed to power off AC socket from ON state for AC Socket#{0}", testedAcSocket);
                    CmTestLog.Failure(failureMessage);
                    testPassed = false;
                }

                acSocketPower = this.Channel.GetACSocketPowerState(testedAcSocket);
                if (acSocketPower.powerState != PowerState.OFF)
                {
                    failureMessage = string.Format("!!!Failed to get power state for AC socket#{0}", testedAcSocket);
                    CmTestLog.Failure(failureMessage);
                    testPassed = false;
                }

                acSocketPower = this.Channel.GetACSocketPowerState(testedAcSocket);
                if (acSocketPower.powerState != PowerState.OFF)
                {
                    failureMessage = string.Format("!!!Failed to get power state for AC socket#{0}", testedAcSocket);
                    CmTestLog.Failure(failureMessage);
                    testPassed = false;
                }
            }

            //Test for invalid parameters
            acSocketResponse = this.Channel.SetACSocketPowerStateOn(0);
            if (acSocketResponse.completionCode != CompletionCode.ParameterOutOfRange)
            {
                failureMessage = string.Format("!!!Failed During SetACSocketPowerStateOn(0), response is: {0}", acSocketResponse.completionCode);
                CmTestLog.Failure(failureMessage);
                testPassed = false;
            }

            acSocketResponse = this.Channel.SetACSocketPowerStateOn(9999);
            if (acSocketResponse.completionCode != CompletionCode.ParameterOutOfRange)
            {
                failureMessage = string.Format("!!!Failed During SetACSocketPowerStateOn(0), response is: {0}", acSocketResponse.completionCode);
                CmTestLog.Failure(failureMessage);
                testPassed = false;
            }

            acSocketResponse = this.Channel.SetACSocketPowerStateOn(4);
            if (acSocketResponse.completionCode != CompletionCode.ParameterOutOfRange)
            {
                failureMessage = string.Format("!!!Failed During SetACSocketPowerStateOn(0), response is: {0}", acSocketResponse.completionCode);
                CmTestLog.Failure(failureMessage);
                testPassed = false;
            }

            Console.WriteLine("\n++++++++++++++++++++++++++++++++");
            failureMessage = "!!!!!!!!! Successfully finished execution of ACSocketPowerTests.";
            Console.WriteLine(failureMessage);

            CmTestLog.End(testPassed);
            return(testPassed);
        }
        /// <summary>
        /// Test Command: ReadBladeLog, ClearBladeLog. The test case verifies:
        /// The command returns completion code success on server blades;
        /// ReadBladeLog succeeds even after all logs are cleared.
        /// </summary>
        /// <returns>True if all check-points pass; false, otherwise.</returns>
        public bool ReadClearBladeLogTest()
        {
            CmTestLog.Start();
            ChassisLogResponse readLogResponse;
            BladeResponse      clearLogResponse;
            bool testPassed = true;

            int[] serverLocations, jbodLocations;
            if (!this.GetBladeLocations(blade => blade.bladeType.Equals(CmConstants.ServerBladeType), out serverLocations) ||
                !this.GetBladeLocations(blade => blade.bladeType.Equals(CmConstants.JbodBladeType), out jbodLocations))
            {
                CmTestLog.Failure("Cannot find a server/ Jbod blade to execute automation against");
                CmTestLog.End(false);
                return(false);
            }

            if (serverLocations == null || serverLocations.Length == 0)
            {
                CmTestLog.Warning("There are no server blades to execute the test against.");
            }
            else
            {
                int bladeId = serverLocations.RandomOrDefault();
                CmTestLog.Success("Found server blade at location: " + bladeId);

                CmTestLog.Info("Power on Blade# " + bladeId);
                var powerOnResponse = this.Channel.SetPowerOn(bladeId);
                testPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, powerOnResponse.completionCode, string.Format("Blade# {0} is powered on", bladeId));

                CmTestLog.Info("Read logs from Blade# " + bladeId);
                readLogResponse = this.Channel.ReadBladeLog(bladeId);
                testPassed     &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, readLogResponse.completionCode, "Received Read logs from Blade# " + bladeId);

                CmTestLog.Info("Clear logs on Blade# " + bladeId + " and read again");
                clearLogResponse = this.Channel.ClearBladeLog(bladeId);
                testPassed      &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, clearLogResponse.completionCode, "Logs on Blade# " + bladeId + " is cleared");

                readLogResponse = this.Channel.ReadBladeLog(bladeId);
                testPassed     &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, readLogResponse.completionCode, "Read logs from Blade# " + bladeId);
            }

            // [TFS WorkItem: 2730] ReadBladeLog: Verify command is not valid to run on JBOD blade
            if (jbodLocations == null || jbodLocations.Length == 0)
            {
                CmTestLog.Warning("There are no JBODs to execute the test against.");
            }
            else
            {
                int JbodId = jbodLocations.RandomOrDefault();
                CmTestLog.Success("Found JBOD blade at location " + JbodId);
                CmTestLog.Info("Power on Blade# " + JbodId);
                var powerOnResponse = this.Channel.SetPowerOn(JbodId);
                testPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, powerOnResponse.completionCode, string.Format("JBOD at location# {0} is powered on", JbodId));

                CmTestLog.Info("Trying to read logs for JBOD");
                readLogResponse = this.Channel.ReadBladeLog(JbodId);
                testPassed     &= ChassisManagerTestHelper.AreEqual(CompletionCode.CommandNotValidForBlade, readLogResponse.completionCode, "Received CommandNotValidForBlade to Read logs for JBOD# " + JbodId);

                // [TFS WorkItem: 2731] ClearBladeLog: Verify command is not valid to run on JBOD blade
                CmTestLog.Info("Trying to clear logs for JBOD");
                clearLogResponse = this.Channel.ClearBladeLog(JbodId);
                testPassed      &= ChassisManagerTestHelper.AreEqual(CompletionCode.CommandNotValidForBlade, clearLogResponse.completionCode, "Received CommandNotValidForBlade to clear logs for JBOD# " + JbodId);
            }

            this.EmptyLocations = this.GetEmptyLocations();
            if (EmptyLocations == null || EmptyLocations.Length == 0)
            {
                CmTestLog.Warning("There are no Empty slots to execute the test against.");
            }
            else
            {
                int slotId = EmptyLocations.RandomOrDefault();
                CmTestLog.Success("Found empty slot at location " + slotId);
                CmTestLog.Info("Trying to read logs for Empty location");
                readLogResponse = this.Channel.ReadBladeLog(slotId);
                testPassed     &= ChassisManagerTestHelper.AreEqual(CompletionCode.Timeout, readLogResponse.completionCode, "Received Timeout to Read logs for emoty slot# " + slotId);

                // [TFS WorkItem: 2731] ClearBladeLog: Verify command is not valid to run on JBOD blade
                CmTestLog.Info("Trying to clear logs for empty slot");
                clearLogResponse = this.Channel.ClearBladeLog(slotId);
                testPassed      &= ChassisManagerTestHelper.AreEqual(CompletionCode.Timeout, clearLogResponse.completionCode, "Received Timeout to clear logs for empty slot# " + slotId);
            }
            CmTestLog.End(testPassed);
            return(true);
        }