public void SetInvalidIpv6DnsConfigurationTest()
{
// turn OFF DHCP
RunTest <NetworkInterface>(
new Backup <NetworkInterface>(
() =>
{
NetworkInterface ni = TurnOffDhcpIpv6();
return(ni);
}),
() =>
{
DNSInformation testInformation = new DNSInformation();
testInformation.FromDHCP = false;
testInformation.DNSManual =
new IPAddress[]
{
new IPAddress()
{
IPv6Address = "FF02:1", Type = IPType.IPv6
}
};
string reason = string.Empty;
RunStep(() =>
{
Client.SetDNS(testInformation.FromDHCP, testInformation.SearchDomain,
testInformation.DNSManual);
},
"Set DNS configuration - negative test",
"Sender/InvalidArgVal/InvalidIPv6Address",
true);
DoRequestDelay();
DNSInformation actualInformation = GetDnsConfiguration();
Assert(actualInformation != null, "Failed to get current DNS configuration",
"Check that current DNS configuration returned from the DUT");
bool bValid = actualInformation.IsValidDnsInformation(false, out reason);
Assert(bValid, reason, "Validate current DNS configuration");
bool bFound = (actualInformation.DNSManual != null && actualInformation.DNSManual.Length > 0) &&
actualInformation.DNSManual.Where(
IP => IP.IPv4Address == testInformation.DNSManual[0].IPv6Address).
Count() > 0;
Assert(!bFound, "DUT set address to invalid value",
"Check that current IPv6 addresses list does not contain invalid value");
},
(ni) =>
{
if (ni.IPv6.Config.DHCP != IPv6DHCPConfiguration.Off)
{
RestoreNetworkInterface(ni.token, ni);
}
});
}
DNSInformation GetOriginalDnsConfiguration()
{
DNSInformation originalInformation = GetDnsConfiguration();
Assert(originalInformation != null, "Failed to get original DNS configuration", "Check that original DNS configuration returned from the DUT");
return(originalInformation);
}
protected DNSInformation GetDnsConfiguration()
{
DNSInformation dnsInformation = null;
RunStep(() => { dnsInformation = Client.GetDNS(); }, "Get DNS configuration");
return(dnsInformation);
}
protected void SetDnsConfiguration(DNSInformation information, string stepName)
{
RunStep(() =>
{
Client.SetDNS(
information.FromDHCP,
information.SearchDomain,
information.DNSManual);
}, stepName);
}
public void SetDnsConfigurationSearchDomainTest()
{
RunTest <DNSInformation>(
new Backup <DNSInformation>(() =>
{
DNSInformation originalInformation = GetDnsConfiguration();
Assert(originalInformation != null, "Failed to get original DNS configuration", "Check that original DNS configuration returned from the DUT");
return(originalInformation);
}),
() =>
{
DNSInformation testInformation = new DNSInformation();
testInformation.SearchDomain = new string[] { "domain.name" };
testInformation.FromDHCP = false;
SetDnsConfiguration(testInformation);
double timeout = ((double)_operationDelay) / 1000;
BeginStep(string.Format("Wait {0} seconds to allow the DUT to apply settings", timeout.ToString("0.000")));
Sleep(_operationDelay);
StepPassed();
DNSInformation actual = GetDnsConfiguration();
Assert(actual != null, "Failed to get current DNS configuration", "Check that DNS configuration returned from the DUT");
Assert(actual.FromDHCP == false, "FromDHCP is TRUE", "Check that FromDHCP is false");
Assert(actual.SearchDomain != null, "No Search Domains returned from the DUT", "Check that the DUT returned Search Domains");
string actualDomainsDescription = DumpStringArray(actual.SearchDomain);
bool domainFound = actual.SearchDomain.Contains(testInformation.SearchDomain[0],
StringComparer.InvariantCultureIgnoreCase);
Assert(domainFound,
string.Format("SearchDomain does not equal to the value was set. "),
"Validate SearchDomain value",
string.Format("Expected: '{0}' should be presented, actual: {1}", testInformation.SearchDomain[0], actualDomainsDescription));
},
(originalInformation) =>
{
SetDnsConfiguration(originalInformation, "Restore DNS configuration");
}
);
}
public void GetDnsConfigurationTest()
{
RunTest(() =>
{
DNSInformation dnsInformation = GetDnsConfiguration();
Assert(dnsInformation != null,
"DNSInformation not returned",
"Check that DUT returned DNSInformation");
string error;
bool dnsInformationOk = dnsInformation.IsValidDnsInformation(false, out error);
Assert(dnsInformationOk, error, "Validate DNS information");
});
}
/// <summary>
/// Checks if DNS information is valid.
/// </summary>
/// <param name="dnsInformation">DNS information.</param>
/// <param name="ipAddressMandatory">True, if IP address cannot be omitted.</param>
/// <param name="reason">Failure reason.</param>
/// <returns></returns>
public static bool IsValidDnsInformation(this DNSInformation dnsInformation, bool ipAddressMandatory, out string reason)
{
reason = string.Empty;
if (dnsInformation.FromDHCP)
{
if ((dnsInformation.DNSManual != null) &&
(dnsInformation.DNSManual.Length > 0))
{
reason = "DNSManual is not empty, while FromDHCP is true";
return(false);
}
if ((dnsInformation.DNSFromDHCP != null) &&
!AreValidAddresses(dnsInformation.DNSFromDHCP, ipAddressMandatory, out reason))
{
return(false);
}
}
else
{
if ((dnsInformation.DNSFromDHCP != null) &&
(dnsInformation.DNSFromDHCP.Length > 0))
{
reason = "DNSFromDHCP is not empty, while FromDHCP is false";
return(false);
}
if ((dnsInformation.DNSManual != null) &&
!AreValidAddresses(dnsInformation.DNSManual, ipAddressMandatory, out reason))
{
return(false);
}
}
if (dnsInformation.SearchDomain != null)
{
foreach (string hostname in dnsInformation.SearchDomain)
{
if (!IsValidHostName(hostname))
{
reason = string.Format("Invalid host name ({0})", hostname);
return(false);
}
}
}
return(true);
}
void SetDnsConfiguration()
{
DNSInformation testInformation = new DNSInformation();
testInformation.FromDHCP = false;
testInformation.DNSManual =
new IPAddress[]
{
new IPAddress()
{
IPv4Address = _environmentSettings.DnsIpv4, Type = IPType.IPv4
}
};
SetDnsConfiguration(testInformation);
double timeout = ((double)_operationDelay) / 1000;
BeginStep(string.Format("Wait {0} seconds to allow the DUT to apply settings", timeout.ToString("0.000")));
Sleep(_operationDelay);
StepPassed();
DNSInformation actualInformation = GetDnsConfiguration();
Assert(actualInformation != null, "Failed to get current DNS configuration", "Check that current DNS configuration returned from the DUT");
BeginStep("Check current DNS configuration");
bool bAllEquals;
bool bEquals = (actualInformation.FromDHCP == testInformation.FromDHCP);
LogStepEvent(string.Format("FromDHCP: expected - {0}, actual - {1}", testInformation.FromDHCP,
actualInformation.FromDHCP));
bAllEquals = bEquals;
string actualIpDescription;
actualIpDescription = DumpIPArray(actualInformation.DNSManual);
string expectedAddress = testInformation.DNSManual[0].IPv4Address;
IPType expectedType = testInformation.DNSManual[0].Type;
if (actualInformation.DNSManual.Where(
A => A.Type == expectedType && A.IPv4Address == expectedAddress).Count() > 0)
{
bEquals = true;
}
else
{
bEquals = false;
}
LogStepEvent(string.Format("DNSManual: expected - {0} should be presented, actual - {1}",
expectedAddress, actualIpDescription));
bAllEquals = bAllEquals && bEquals;
// Compare DNSFromDHCP part
actualIpDescription = DumpIPArray(actualInformation.DNSFromDHCP);
if (actualInformation.DNSFromDHCP == null)
{
bEquals = true;
}
else
{
bEquals = (actualInformation.DNSFromDHCP.Length == 0);
}
string expectedDescription = "No DNSFromDHCP";
LogStepEvent(string.Format("DNSFromDHCP: expected - {0}, actual - {1}",
expectedDescription, actualIpDescription));
bAllEquals = bAllEquals && bEquals;
// Compare Search Domain
// ToDo : remove search domain validation.
// The DUT may leave old Search Domain (TT Release Notes)
//expectedDescription = "no Search Domains";
//string actualDomainsDescription = DumpStringArray(actualInformation.SearchDomain);
//if (actualInformation.SearchDomain == null)
//{
// bEquals = true;
//}
//else
//{
// bEquals = (actualInformation.SearchDomain.Length == 0);
//}
//LogStepEvent(string.Format("SearchDomain: expected - {0}, actual - {1}",
//expectedDescription, actualDomainsDescription));
//bAllEquals = bAllEquals && bEquals;
// Dump total result
if (!bAllEquals)
{
throw new AssertException("Current DNS configuration differs from configuration was set");
}
StepPassed();
}
void RestoreOriginalDnsConfiguration(DNSInformation originalInformation)
{
SetDnsConfiguration(originalInformation, "Restore DNS configuration");
}
public void SetDnsConfigurationDnsFromDHCPTest()
{
NetworkInterface ni = null;
RunTest <DNSInformation>(
new Backup <DNSInformation>(() =>
{
DNSInformation originalInformation = GetDnsConfiguration();
string reason = null;
Assert((originalInformation != null) && originalInformation.IsValidDnsInformation(false, out reason),
reason == null ? "Failed to get original DNS configuration" : reason,
"Check that valid DNS configuration returned from the DUT");
ni = TurnOnDhcpIpv4();
return(originalInformation);
}),
() =>
{
DNSInformation testInformation = new DNSInformation();
testInformation.FromDHCP = true;
SetDnsConfiguration(testInformation);
double timeout = ((double)_operationDelay) / 1000;
BeginStep(string.Format("Wait {0} seconds to allow the DUT to interact with DHCP server", timeout.ToString("0.000")));
Sleep(_operationDelay);
StepPassed();
DNSInformation actualInformation = GetDnsConfiguration();
string reason = null;
Assert((actualInformation != null) && actualInformation.IsValidDnsInformation(false, out reason),
reason == null ? "Failed to get original DNS configuration" : reason,
"Check that original DNS configuration returned from the DUT");
Assert(actualInformation != null, "Failed to get current DNS configuration", "Check that current DNS configuration returned from the DUT");
BeginStep("Check current DNS configuration");
bool bAllEquals;
bool bEquals = (actualInformation.FromDHCP == testInformation.FromDHCP);
LogStepEvent(string.Format("FromDHCP: expected - {0}, actual - {1}", testInformation.FromDHCP,
actualInformation.FromDHCP));
bAllEquals = bEquals;
string actualIpDescription;
actualIpDescription = DeviceManagementNetworkTestSuite.DumpIPArray(actualInformation.DNSManual);
string expectedAddress = "No IP Address";
if (actualInformation.DNSManual != null && actualInformation.DNSManual.Count() > 0)
{
bEquals = false;
}
else
{
bEquals = true;
}
LogStepEvent(string.Format("DNSManual: expected - {0}, actual - {1}",
expectedAddress, actualIpDescription));
bAllEquals = bAllEquals && bEquals;
/*************************************************/
actualIpDescription = DeviceManagementNetworkTestSuite.DumpIPArray(actualInformation.DNSFromDHCP);
if (actualInformation.DNSFromDHCP == null)
{
bEquals = false;
}
else
{
bEquals = (actualInformation.DNSFromDHCP.Length > 0);
}
string expectedDescription = "List of DNS servers";
LogStepEvent(string.Format("DNSFromDHCP: expected - {0}, actual - {1}",
expectedDescription, actualIpDescription));
bAllEquals = bAllEquals && bEquals;
/*********************************************************/
if (!bAllEquals)
{
throw new AssertException("Current DNS configuration differs from configuration was set");
}
StepPassed();
},
(originalInformation) =>
{
SetDnsConfiguration(originalInformation, "Restore DNS configuration");
// if DHCP was ON, it has not been changed
if (!ni.IPv4.Config.DHCP)
{
// restore network interface configuration
RestoreNetworkInterface(ni.token, ni);
}
}
);
}
public void SetDnsConfigurationDnsManualIpv6Test()
{
NetworkInterface ni = null;
RunTest <DNSInformation>(
new Backup <DNSInformation>(() =>
{
DNSInformation originalInformation = GetDnsConfiguration();
Assert(originalInformation != null, "Failed to get original DNS configuration", "Check that original DNS configuration returned from the DUT");
ni = TurnOffDhcpIpv6();
return(originalInformation);
}),
() =>
{
DNSInformation testInformation = new DNSInformation();
testInformation.FromDHCP = false;
testInformation.DNSManual =
new IPAddress[]
{
new IPAddress()
{
IPv6Address = _environmentSettings.DnsIpv6, Type = IPType.IPv6
}
};
SetDnsConfiguration(testInformation);
double timeout = ((double)_operationDelay) / 1000;
BeginStep(string.Format("Wait {0} seconds to allow the DUT to apply settings", timeout.ToString("0.000")));
Sleep(_operationDelay);
StepPassed();
DNSInformation actualInformation = GetDnsConfiguration();
Assert(actualInformation != null, "Failed to get current DNS configuration", "Check that current DNS configuration returned from the DUT");
BeginStep("Check current DNS configuration");
bool bAllEquals;
bool bEquals = (actualInformation.FromDHCP == testInformation.FromDHCP);
LogStepEvent(string.Format("FromDHCP: expected - {0}, actual - {1}", testInformation.FromDHCP,
actualInformation.FromDHCP));
bAllEquals = bEquals;
string actualIpDescription;
actualIpDescription = DeviceManagementNetworkTestSuite.DumpIPArray(actualInformation.DNSManual);
string expectedAddress = testInformation.DNSManual[0].IPv6Address;
IPType expectedType = testInformation.DNSManual[0].Type;
if (actualInformation.DNSManual.Where(
A => A.Type == expectedType && A.IPv6Address == expectedAddress).Count() > 0)
{
bEquals = true;
}
else
{
bEquals = false;
}
LogStepEvent(string.Format("DNSManual: expected - {0} should be presented, actual - {1}",
expectedAddress, actualIpDescription));
bAllEquals = bAllEquals && bEquals;
/*************************************************/
actualIpDescription = DeviceManagementNetworkTestSuite.DumpIPArray(actualInformation.DNSFromDHCP);
if (actualInformation.DNSFromDHCP == null)
{
bEquals = true;
}
else
{
bEquals = (actualInformation.DNSFromDHCP.Length == 0);
}
string expectedDescription = "No DNSFromDHCP";
LogStepEvent(string.Format("DNSFromDHCP: expected - {0}, actual - {1}",
expectedDescription, actualIpDescription));
bAllEquals = bAllEquals && bEquals;
/*********************************************************/
if (!bAllEquals)
{
throw new AssertException("Current DNS configuration differs from configuration was set");
}
StepPassed();
},
(originalInformation) =>
{
SetDnsConfiguration(originalInformation, "Restore DNS configuration");
if (ni.IPv6.Config.DHCP != IPv6DHCPConfiguration.Off)
{
// restore network interface configuration
RestoreNetworkInterface(ni.token, ni);
}
}
);
}
protected void SetDnsConfiguration(DNSInformation information)
{
SetDnsConfiguration(information, "Set DNS configuration");
}
