Bruno automation test code upload: New test cases added: some networking and TR069 test cases.
Change-Id: Ie10f54b238d41c4b05e570a9716890f4fdf7c578
diff --git a/acs.py b/acs.py
index 4025428..8725e02 100755
--- a/acs.py
+++ b/acs.py
@@ -24,6 +24,7 @@
'url': None,
# expected image version ID on ACS
'imageVersion': expected_version,
+ 'acs_path': None,
'outfile': 'cmdOutput.txt'}
for s in kwargs:
self.acs_info[s] = kwargs[s]
@@ -47,17 +48,30 @@
else:
self.acs_info['imageVersion'] = expected_version
- def SaveConfiguration(self):
+ def ParseAppIDFromACSURL(self, url='https://acs.e2e.gfsvc.com/cwmp'):
+ """Parse app_id from ACS instance host name."""
+ pass
+
+ def SaveConfiguration(self, profile_id, version_id, app_id,
+ host='https://acs.e2e.gfsvc.com/cwmp'):
"""Run the ACS configuration script from Google3 location."""
+ if not version_id:
+ v_id = self.acs_info['imageVersion']
+ else:
+ v_id = version_id
+
cur_dir = os.getcwd()
print '============' + cur_dir
- os.chdir('/home/lmeng/git_project/google3/isp/'
- 'fiber/testing/automated_tests/bulkupgrade/')
+ # the acs_path is the google3 repository where upgrade_test.py
+ # locates. This test depends on it to modify ACS datastore.
+ os.chdir(self.acs_info['acs_path'])
print '============' + os.getcwd()
os.system(
'blaze test --notest_loasd --test_arg=--imageVersion='
- + self.acs_info['imageVersion']
- + ' --test_strategy=local :bulkupgrade_test ')
+ + v_id + ' --test_arg=--profile_id='
+ + profile_id + ' --test_arg=--app_id=' + app_id
+ + ' --test_arg=--host=' + host
+ + ' --test_strategy=local :upgrade_test ')
os.chdir(cur_dir)
print '============' + os.getcwd()
@@ -71,19 +85,95 @@
log_list.append(line.strip())
return log_list
- def ParseParameterNames(self, cmd_list):
- """Parse the command output from nbi_client, retrieve parameter names."""
+ def ParseParameterAccessStates(self, cmd_list):
+ """Find out if a parameter is 'writable' or 'read-write'.
+
+ This method process the nbi_client getParameterNames() call result
+ to find out the access state of the parameters.
+ Args:
+ cmd_list: the getParameterNames() call returned result list
+ Returns:
+ a dictionary: parameter name as index, and its access state
+ as value.
+ """
if ('FAILED' in cmd_list[0]) or (not 'SUCCESS' in cmd_list[0]):
info = self.log.CreateErrorInfo(
- 'Critical', 'nbi_clienet call failed. Check log for details.')
+ 'Critical', 'nbi_clienet call failed. ' + str(cmd_list[0]))
self.log.SendLine(None, info)
return False
+ para_dict = {}
+ for line in cmd_list:
+ if 'name:' in line:
+ name = re.sub('.*name:\s*\"(.*)\".*', r'\1', line)
+ index = cmd_list.index(line)+1
+ access = re.sub('.*writable:\s*([a-zA-Z]+)', r'\1', cmd_list[index])
+ para_dict.update({name: access})
+ return para_dict
+
+ def CheckCmdCall(self, cmd_list):
+ """Check if the RPC call is a success or failure."""
+ if ('FAILED' in cmd_list[0]) or (not 'SUCCESS' in cmd_list[0]):
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'nbi_client call failed. ' + str(cmd_list[0]))
+ self.log.SendLine(None, info)
+ return False
+ else:
+ return True
+
+ def ParseManagementURL(self, cmd_list):
+ """Parse Management URL from GetParameterValues query reply message.
+
+ Reply message is in the following format:
+ #########################################################
+ SUCCESS! Response: parameter_value_list {
+ parameter_value_struct {
+ name: "InternetGatewayDevice.ManagementServer.URL"
+ string_value: "https://acs.e2e.gfsvc.com/cwmp"
+ }
+ }
+ #########################################################
+
+ Args:
+ cmd_list: the ACS url information obtained from device log or file
+ Returns:
+ returns the management url found, or return false if url not found
+ """
+ if not cmd_list:
+ return False
+ for line in cmd_list:
+ if ('name:' in line and
+ 'InternetGatewayDevice.ManagementServer.URL' in line):
+ s = cmd_list[cmd_list.index(line)+1]
+ m = re.search('http[s]?://(\w*\.)+com/cwmp', s)
+ if not m:
+ info = self.log.CreateErrorInfo(
+ 'Warning', 'No management server URL found in GetParameterValues '
+ 'query reply.')
+ self.log.SendLine(None, info)
+ return False
+ else:
+ return m.group(0)
+
+ def ParseParameterNames(self, cmd_list, replace_index=False):
+ """Parse the get values RPC call response, retrieve parameter name list.
+
+ Args:
+ cmd_list: the command reply message from nbi_client
+ replace_index: if True, the index digits in parameter names will be
+ replaced with '.{i}.'
+ Returns:
+ return the parsed parameter name list
+ """
+ if not self.CheckCmdCall(cmd_list):
+ return False
+
chk_list = []
for line in cmd_list:
if 'name:' in line:
output = re.sub('.*\"(.*)\".*', r'\1', line)
- output = re.sub(r'(\.)[\d]+(\.)', r'\1{i}\2', output)
+ if replace_index:
+ output = re.sub(r'(\.)[\d]+(\.)', r'\1{i}\2', output)
if chk_list.count(output) < 1:
chk_list.append(output)
return chk_list
diff --git a/config.cfg b/config.cfg
index 602b4d9..ea3fef7 100644
--- a/config.cfg
+++ b/config.cfg
@@ -1,49 +1,126 @@
-##############################################
-# This is the config file for the test cases #
-# #
-# All test cases share the same config file. #
-# Each test case configuration starts with #
-# the testID of that test case. #
-# #
-# comment line starts with '#' and will not #
-# be parsed as configuration information #
-##############################################
-testID: 11843140
-user = root #obsoleted
-addr = 192.168.1.4
-addr_ipv6 = None
-pwd = google #obsoleted
-bruno_prompt = gfibertv#
-title =Image_Download
-expected_version_id=716006
-expected_version=bruno-koala-5
-downgrade_version=bruno-koala-4
-downgrade_version_id=728001
-acs_url = https://gfiber-acs-staging.appspot.com/cwmp
-# if authentication server is required to access the device
-jump_server = jmp.googlefiber.net
-# if athena server is required to access the device:
-athena_user = your_uname
-athena_pwd = your_pwd
+{
+ "Image_Download":{
+ "comment":["this is a comment line",
+ "this configuration profile is for ImageDownload test case",
+ "the acs_path is the google3 repository where upgrade_test.py locates. This test depends on it to modify ACS datastore."],
+ "testID": ["11843140", "14165036"],
+ "title" : {"11843140":"Image_Download", "14165036":"DownloadInterrupt"},
+ "user" : "root",
+ "addr" : "192.168.1.4",
+ "addr_ipv6" : "2605:a601:fe00:fd18:21a:11ff:fe30:64e6",
+ "pwd" : "google",
+ "bruno_prompt" : "gfibertv#",
+ "expected_version_id": "987010",
+ "expected_version": "bruno-monkey-4",
+ "downgrade_version": "bruno-monkey-3",
+ "downgrade_version_id": "1038003",
+ "acs_url" : "https://gfiber-acs-staging.appspot.com/cwmp",
+ "acs_path": "/home/lmeng/git_project/google3/isp/gfiber/testing/automated_tests/upgrade_test/",
+ "acs_app_id": "gfiber-acs-staging",
+ "acs_host_name": "gfiber-acs-staging.appspot.com",
+ "jump_server" : "jmp.googlefiber.net",
+ "athena_user" : "your_uname",
+ "athena_pwd" : "your_pwd",
+ "profile_id" : "557001"
+ },
+
+ "basic_network_testcases":{
+ "comment":["addr_ipv6_dup: the duplicated address to set on device, in",
+ "or der to detect the address duplication error."],
+ "testID": ["11874111", "11721378"],
+ "title" : {"11874111":"DuplicateIPv6Addr", "11721378":"DHCPv4OverBruno-IS"},
+ "user" : "root",
+ "addr" : "192.168.1.4",
+ "addr_ipv6" : "2605:a601:fe00:fd18:21a:11ff:fe30:64e6",
+ "bruno_prompt" : "gfibertv#",
+ "expected_version_id": "987010",
+ "expected_version": "bruno-monkey-4",
+ "addr_ipv6_dup":"2605:a601:fe00:fd18:21a:11ff:fe30:6383"
+ },
+
+ "dataModel":{
+ "testID": ["14187024", "14165033", "14315008", "14165035", "14314007",
+ "11865133", "14335001", "14266498", "14319149", "14314008",
+ "11722375", "14315009", "14314009", "14165038", "15643845"],
+ "title" : {"14187024":"TR140_DataModel",
+ "14165033":"GVSB_DataModel",
+ "14315008":"TR098_DataModel",
+ "14165035":"MoCA_DataModel",
+ "14314007":"TR181_DataModel",
+ "11865133":"TR135_DataModel",
+ "14335001":"X_CATAWAMPUS-ORG_DataModel",
+ "14266498":"FlashDevice_DataModel",
+ "14319149":"X_GOOGLE-COM_DataModel",
+ "14314008":"TR157_DataModel",
+ "11722375":"SetParameterValuesRPC",
+ "14315009":"ManagementServerURL",
+ "14314009":"MonitorTemperature",
+ "14165038":"AutoChannelEnable",
+ "15643845":"NTPTimeZoneConfig"},
+ "user" : "root",
+ "addr" : "192.168.1.4",
+ "addr_ipv6" : "2605:a601:fe00:fd18:21a:11ff:fe30:64e6",
+ "req_file" : "data/DataModel_requirement.cfg",
+ "bruno_prompt" : "gfibertv#",
+ "expected_version_id": "959004",
+ "expected_version": "bruno-monkey-2",
+ "acs_url" : "https://gfiber-acs-staging.appspot.com/cwmp",
+ "nbi_client_path" : "/home/lmeng/git_project/google3/blaze-bin/java/com/google/fiber/provisioning/acs/client/nbi/nbi_client",
+ "para_tree_file" : "ParameterTree.xml",
+ "from_which_param_to_set": "None",
+ "param_path" : "."
+ },
+
+ "dataModel_WiFi":{
+ "comment":["wifi_params type: e.g., string_value, is the data type accepted by nbi_client RPC call."],
+ "testID": ["14165034"],
+ "title" : {"14165034":"WiFi_configuration"},
+ "user" : "root",
+ "addr" : "192.168.1.4",
+ "addr_ipv6" : "2605:a601:fe00:fd18:21a:11ff:fe30:64e6",
+ "bruno_prompt" : "gfibertv#",
+ "expected_version_id": "987010",
+ "expected_version": "bruno-monkey-4",
+ "acs_url" : "https://gfiber-acs-staging.appspot.com/cwmp",
+ "nbi_client_path" : "/home/lmeng/git_project/google3/blaze-bin/java/com/google/fiber/provisioning/acs/client/nbi/nbi_client",
+ "account_id":"5438577436",
+ "device_label":"0101209088BC",
+ "wifi_params":{
+ "Google.Wifi.SSID":{"string_value":"Home"},
+ "Google.Wifi.Home.SSID_2GHz":{"string_value":"Home"},
+ "Google.Wifi.Enable":{"boolean_value":"true"},
+ "Google.Wifi.BeaconType":{"string_value": "Basic"},
+ "Google.Wifi.BasicEncryptionModes":{"string_value":"WEPEncryption"}}
+ },
+
+ "basic_tr069_test_case":{
+ "comment":["Factory_reset test case needs to manually reset the device"],
+ "testID": ["11865129", "11721375"],
+ "title" : {"11865129":"IPv6_Connection",
+ "11721375":"Factory_Reset"
+ },
+ "user" : "root",
+ "addr" : {"value":"192.168.1.4", "comment":"device ipv4 address"},
+ "expected_version": "bruno-monkey-4",
+ "addr_ipv6" : {"value":"2605:a601:fe00:fd18:21a:11ff:fe30:6383",
+ "comment":"device ipv6 address"},
+ "acs_ipv6" : "2001:4860:8005::8d",
+ "gvsb_host": "https://gvsb.e2e.gfsvc.com/rpc",
+ "acs_url" : "https://acs.e2e.gfsvc.com/cwmp",
+ "bruno_prompt" : "gfibertv#"
+ },
+
+ "blocked_test_case":{
+ "testID": ["14314009", "14165038"],
+ "title" : {"14314009":"MonitorTemperature",
+ "14165038":"AutoChannelEnable"},
+ "user" : "root",
+ "addr" : "192.168.1.4",
+ "addr_ipv6" : "2605:a601:fe00:fd18:21a:11ff:fe30:64e6",
+ "bruno_prompt" : "gfibertv#"
+ }
+}
-testID: 14187024
-title =DataModel
-req_file = DataModel_requirement.cfg
-mis_file = missing_parameters.log
-user = root
-pwd = google
-addr = 192.168.1.4
-addr_ipv6 = 2605:a601:fe00:fd18:21a:11ff:fe30:6383
-serial_num = None
-bruno_prompt = gfibertv#
-expected_version_id=728001
-expected_version=bruno-koala-4
-acs_url = https://gfiber-acs-staging.appspot.com/cwmp
-jump_server = jmp.googlefiber.net
-athena_user = your_uname
-athena_pwd = your_pwd
-nbi_client_path = /home/$your_uname/git_project/google3/blaze-bin/java/com/google/fiber/provisioning/acs/client/nbi/nbi_client
-para_tree_file = tree.xml
diff --git a/data/DataModel_requirement_1.cfg b/data/DataModel_requirement_1.cfg
deleted file mode 100644
index c940323..0000000
--- a/data/DataModel_requirement_1.cfg
+++ /dev/null
@@ -1,509 +0,0 @@
-Device.Bridging.
-Device.Bridging.Bridge.{i}.
-Device.Bridging.Bridge.{i}.Port.{i}.
-Device.Bridging.Bridge.{i}.Port.{i}.Stats.
-Device.Bridging.Bridge.{i}.VLANPort.{i}.
-Device.DeviceInfo
-Device.DeviceInfo.AdditionalHardwareVersion
-Device.DeviceInfo.AdditionalSoftwareVersion
-Device.DeviceInfo.Description
-Device.DeviceInfo.HardwareVersion
-Device.DeviceInfo.Manufacturer
-Device.DeviceInfo.ManufacturerOUI
-Device.DeviceInfo.MemoryStatus.
-Device.DeviceInfo.MemoryStatus.Free
-Device.DeviceInfo.MemoryStatus.Total
-Device.DeviceInfo.ModelName
-Device.DeviceInfo.NetworkProperties.
-Device.DeviceInfo.ProcessStatus.
-Device.DeviceInfo.ProcessStatus.CPUUsage
-Device.DeviceInfo.ProcessStatus.Process.{i}.
-Device.DeviceInfo.ProcessStatus.Process.{i}.CPUTime
-Device.DeviceInfo.ProcessStatus.Process.{i}.Command
-Device.DeviceInfo.ProcessStatus.Process.{i}.PID
-Device.DeviceInfo.ProcessStatus.Process.{i}.Priority
-Device.DeviceInfo.ProcessStatus.Process.{i}.Size
-Device.DeviceInfo.ProcessStatus.Process.{i}.State
-Device.DeviceInfo.ProcessStatus.ProcessNumberOfEntries
-Device.DeviceInfo.Processor.{i}.
-Device.DeviceInfo.ProcessorNumberOfEntries
-Device.DeviceInfo.ProductClass
-Device.DeviceInfo.ProxierInfo.
-Device.DeviceInfo.SerialNumber
-Device.DeviceInfo.SoftwareVersion
-Device.DeviceInfo.SupportedDataModel.{i}.
-Device.DeviceInfo.SupportedDataModelNumberOfEntries
-Device.DeviceInfo.TemperatureStatus.
-Device.DeviceInfo.TemperatureStatus.TemperatureSensor.{i}.
-Device.DeviceInfo.TemperatureStatus.TemperatureSensorNumberOfEntries
-Device.DeviceInfo.UpTime
-Device.DeviceInfo.VendorConfigFile.{i}.
-Device.DeviceInfo.VendorConfigFileNumberOfEntries
-Device.DeviceInfo.VendorLogFile.{i}.
-Device.DeviceInfo.VendorLogFileNumberOfEntries
-Device.Ethernet.
-Device.Ethernet.Interface.{i}.
-Device.Ethernet.Interface.{i}.DuplexMode
-Device.Ethernet.Interface.{i}.Enable
-Device.Ethernet.Interface.{i}.LastChange
-Device.Ethernet.Interface.{i}.LowerLayers
-Device.Ethernet.Interface.{i}.MACAddress
-Device.Ethernet.Interface.{i}.MaxBitRate
-Device.Ethernet.Interface.{i}.Name
-Device.Ethernet.Interface.{i}.Stats.
-Device.Ethernet.Interface.{i}.Stats.BroadcastPacketsReceived
-Device.Ethernet.Interface.{i}.Stats.BroadcastPacketsSent
-Device.Ethernet.Interface.{i}.Stats.BytesReceived
-Device.Ethernet.Interface.{i}.Stats.BytesSent
-Device.Ethernet.Interface.{i}.Stats.DiscardPacketsReceived
-Device.Ethernet.Interface.{i}.Stats.DiscardPacketsSent
-Device.Ethernet.Interface.{i}.Stats.ErrorsReceived
-Device.Ethernet.Interface.{i}.Stats.ErrorsSent
-Device.Ethernet.Interface.{i}.Stats.MulticastPacketsReceived
-Device.Ethernet.Interface.{i}.Stats.MulticastPacketsSent
-Device.Ethernet.Interface.{i}.Stats.PacketsReceived
-Device.Ethernet.Interface.{i}.Stats.PacketsSent
-Device.Ethernet.Interface.{i}.Stats.UnicastPacketsReceived
-Device.Ethernet.Interface.{i}.Stats.UnicastPacketsSent
-Device.Ethernet.Interface.{i}.Stats.UnknownProtoPacketsReceived
-Device.Ethernet.Interface.{i}.Status
-Device.Ethernet.Interface.{i}.Upstream
-Device.Ethernet.Interface.{i}.X_CATAWAMPUS-ORG_ActualBitRate
-Device.Ethernet.Interface.{i}.X_CATAWAMPUS-ORG_ActualDuplexMode
-Device.Ethernet.InterfaceNumberOfEntries
-Device.Ethernet.Link.{i}.
-Device.Ethernet.Link.{i}.Stats.
-Device.Ethernet.LinkNumberOfEntries
-Device.Ethernet.RMONStats.{i}.
-Device.Ethernet.VLANTerminationNumberOfEntries
-Device.IP.ActivePort.{i}.
-Device.IP.Diagnostics.DownloadDiagnostics.
-Device.IP.Diagnostics.IPPing.
-Device.IP.Diagnostics.TraceRoute.
-Device.IP.Diagnostics.TraceRoute.RouteHops.{i}.
-Device.IP.Diagnostics.UDPEchoConfig.
-Device.IP.Diagnostics.UploadDiagnostics.
-Device.IP.Interface.{i}.
-Device.IP.Interface.{i}.IPv4Address.{i}.
-Device.IP.Interface.{i}.IPv6Address.{i}.
-Device.IP.Interface.{i}.IPv6Prefix.{i}.
-Device.IP.Interface.{i}.Stats.{i}.
-Device.InterfaceStackNumberOfEntries
-Device.ManagementServer.
-Device.ManagementServer.AutonomousTransferCompletePolicy.
-Device.ManagementServer.CWMPRetryIntervalMultiplier
-Device.ManagementServer.CWMPRetryMinimumWaitInterval
-Device.ManagementServer.ConnectionRequestPassword
-Device.ManagementServer.ConnectionRequestURL
-Device.ManagementServer.ConnectionRequestUsername
-Device.ManagementServer.DUStateChangeComplPolicy.
-Device.ManagementServer.DefaultActiveNotificationThrottle
-Device.ManagementServer.DownloadAvailability.
-Device.ManagementServer.DownloadAvailability.Announcement.
-Device.ManagementServer.DownloadAvailability.Announcement.Group.{i}.
-Device.ManagementServer.DownloadAvailability.Query.
-Device.ManagementServer.EmbeddedDevice.{i}.
-Device.ManagementServer.EnableCWMP
-Device.ManagementServer.ManageableDevice.{i}.
-Device.ManagementServer.ManageableDeviceNumberOfEntries
-Device.ManagementServer.ParameterKey
-Device.ManagementServer.Password
-Device.ManagementServer.PeriodicInformEnable
-Device.ManagementServer.PeriodicInformInterval
-Device.ManagementServer.PeriodicInformTime
-Device.ManagementServer.STUNEnable
-Device.ManagementServer.URL
-Device.ManagementServer.UpgradesManaged
-Device.ManagementServer.Username
-Device.ManagementServer.VirtualDevice.{i}.
-Device.MoCA.
-Device.MoCA.Interface.{i}.AssociatedDeviceNumberOfEntries
-Device.MoCA.Interface.{i}.BackupNC
-Device.MoCA.Interface.{i}.CurrentOperFreq
-Device.MoCA.Interface.{i}.CurrentVersion
-Device.MoCA.Interface.{i}.Enable
-Device.MoCA.Interface.{i}.FirmwareVersion
-Device.MoCA.Interface.{i}.HighestVersion
-Device.MoCA.Interface.{i}.LastChange
-Device.MoCA.Interface.{i}.LastOperFreq
-Device.MoCA.Interface.{i}.LowerLayers
-Device.MoCA.Interface.{i}.MACAddress
-Device.MoCA.Interface.{i}.Name
-Device.MoCA.Interface.{i}.NetworkCoordinator
-Device.MoCA.Interface.{i}.NodeID
-Device.MoCA.Interface.{i}.PacketAggregationCapability
-Device.MoCA.Interface.{i}.PrivacyEnabled
-Device.MoCA.Interface.{i}.QAM256Capable
-Device.MoCA.Interface.{i}.Stats.BroadcastPacketsReceived
-Device.MoCA.Interface.{i}.Stats.BroadcastPacketsSent
-Device.MoCA.Interface.{i}.Stats.BytesReceived
-Device.MoCA.Interface.{i}.Stats.BytesSent
-Device.MoCA.Interface.{i}.Stats.DiscardPacketsReceived
-Device.MoCA.Interface.{i}.Stats.DiscardPacketsSent
-Device.MoCA.Interface.{i}.Stats.ErrorsReceived
-Device.MoCA.Interface.{i}.Stats.ErrorsSent
-Device.MoCA.Interface.{i}.Stats.MulticastPacketsReceived
-Device.MoCA.Interface.{i}.Stats.MulticastPacketsSent
-Device.MoCA.Interface.{i}.Stats.PacketsReceived
-Device.MoCA.Interface.{i}.Stats.PacketsSent
-Device.MoCA.Interface.{i}.Stats.UnicastPacketsReceived
-Device.MoCA.Interface.{i}.Stats.UnicastPacketsSent
-Device.MoCA.Interface.{i}.Stats.UnknownProtoPacketsReceived
-Device.MoCA.Interface.{i}.Status
-Device.MoCA.Interface.{i}.Upstream
-Device.MoCA.InterfaceNumberOfEntries
-Device.MoCA.Interface.{i}.
-Device.MoCA.Interface.{i}.AssociatedDevice.{i}.
-Device.MoCA.Interface.{i}.QoS.
-Device.MoCA.Interface.{i}.QoS.FlowStats.{i}.
-Device.MoCA.Interface.{i}.Stats.
-Device.PeriodicStatistics.MaxReportSamples
-Device.PeriodicStatistics.MinSampleInterval
-Device.PeriodicStatistics.SampleSet.{i}.Enable
-Device.PeriodicStatistics.SampleSet.{i}.FetchSamples
-Device.PeriodicStatistics.SampleSet.{i}.Name
-Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.CalculationMode
-Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Enable
-Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Failures
-Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.HighThreshold
-Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.LowThreshold
-Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Reference
-Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleMode
-Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleSeconds
-Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SuspectData
-Device.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Values
-Device.PeriodicStatistics.SampleSet.{i}.ParameterNumberOfEntries
-Device.PeriodicStatistics.SampleSet.{i}.ReportEndTime
-Device.PeriodicStatistics.SampleSet.{i}.ReportSamples
-Device.PeriodicStatistics.SampleSet.{i}.ReportStartTime
-Device.PeriodicStatistics.SampleSet.{i}.SampleInterval
-Device.PeriodicStatistics.SampleSet.{i}.SampleSeconds
-Device.PeriodicStatistics.SampleSet.{i}.Status
-Device.PeriodicStatistics.SampleSet.{i}.TimeReference
-Device.PeriodicStatistics.SampleSetNumberOfEntries
-Device.QoS.
-Device.QoS.App.{i}.
-Device.QoS.Classification.{i}.
-Device.QoS.Flow.{i}.
-Device.QoS.Policer.{i}.
-Device.QoS.Queue.{i}.
-Device.QoS.QueueStats.{i}.
-Device.QoS.Shaper.{i}.
-Device.Services.STBService.{i}.
-Device.Services.STBService.{i}.AVPlayers.
-Device.Services.STBService.{i}.AVPlayers.AVPlayer.{i}.
-Device.Services.STBService.{i}.AVStreams.
-Device.Services.STBService.{i}.AVStreams.AVStream{i}.
-Device.Services.STBService.{i}.Applications.
-Device.Services.STBService.{i}.Applications.AudienceStats.
-Device.Services.STBService.{i}.Applications.AudienceStats.Channel.{i}.
-Device.Services.STBService.{i}.Capabilities.AudienceStats.
-Device.Services.STBService.{i}.Capabilities.AudioDecoder.
-Device.Services.STBService.{i}.Capabilities.AudioOutput.
-Device.Services.STBService.{i}.Capabilities.DRM
-Device.Services.STBService.{i}.Capabilities.FrontEnd.
-Device.Services.STBService.{i}.Capabilities.FrontEnd.IP.
-Device.Services.STBService.{i}.Capabilities.PVR.
-Device.Services.STBService.{i}.Capabilities.ServiceMonitoring.
-Device.Services.STBService.{i}.Capabilities.VideoDecoder.
-Device.Services.STBService.{i}.Capabilities.VideoDecoder.MPEG2Part2.
-Device.Services.STBService.{i}.Capabilities.VideoDecoder.MPEG2Part2.ProfileLevel.{i}.
-Device.Services.STBService.{i}.Capabilities.VideoDecoder.MPEG4Part10.
-Device.Services.STBService.{i}.Capabilities.VideoDecoder.MPEG4Part10.ProfileLevel.{i}.
-Device.Services.STBService.{i}.Capabilities.VideoDecoder.MPEG4Part2.
-Device.Services.STBService.{i}.Capabilities.VideoDecoder.MPEG4Part2.ProfileLevel.{i}.
-Device.Services.STBService.{i}.Capabilities.VideoDecoder.SMPTEVC1.
-Device.Services.STBService.{i}.Capabilities.VideoDecoder.SMPTEVC1.ProfileLevel.{i}.
-Device.Services.STBService.{i}.Capabilities.VideoOutput.
-Device.Services.STBService.{i}.Components.
-Device.Services.STBService.{i}.Components.AudioDecoder.{i}.
-Device.Services.STBService.{i}.Components.AudioOutput.{i}.
-Device.Services.STBService.{i}.Components.DRM.{i}.
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.Dejittering.
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroup.{i}.
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroupStats.{i}.
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroupStats.{i}.CurrentDay
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroupStats.{i}.QuarterHour.
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroupStats.{i}.Total
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroup.{i}.GroupAddress
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.IGMP.ClientGroupNumberOfEntries
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.Inbound.{i}.
-Device.Services.STBService.{i}.Components.FrontEnd.{i}.IP.Outbound.{i}.
-Device.Services.STBService.{i}.Components.FrontEndNumberOfEntries
-Device.Services.STBService.{i}.Components.HDMI.{i}.
-Device.Services.STBService.{i}.Components.HDMI.{i}.DisplayDevice
-Device.Services.STBService.{i}.Components.PVR.
-Device.Services.STBService.{i}.Components.PVR.Storage.{i}.
-Device.Services.STBService.{i}.Components.SPDIF.{i}.
-Device.Services.STBService.{i}.Components.VideoDecoder.{i}.
-Device.Services.STBService.{i}.Components.VideoOutput.{i}.
-Device.Services.STBService.{i}.ServiceMonitoring.
-Device.Services.STBService.{i}.ServiceMonitoring.MainStream.{i}.
-Device.Services.STBService.{i}.ServiceMonitoring.MainStream.{i}.Sample.HighLevelMetricStats.
-Device.Services.STBService.{i}.ServiceMonitoring.MainStream.{i}.Sample.VideoResponseStats.
-Device.Services.STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.
-Device.Services.STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.AudioDecoderStats.
-Device.Services.STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.DejitteringStats.
-Device.Services.STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.MPEG2TSStats.
-Device.Services.STBService.{i}.ServiceMonitoring.MainStream.{i}.Total.VideoDecoderStats.
-Device.Services.STBServiceNumberOfEntries
-Device.Services.STBService{i}.Capabilities.
-Device.Services.StorageServices.{i}.
-Device.Services.StorageServices.{i}.LogicalVolume.{i}.
-Device.Services.StorageServices.{i}.LogicalVolume.{i}.Folder.{i}.
-Device.Services.StorageServices.{i}.LogicalVolume.{i}.Folder.{i}.Quota.
-Device.Services.StorageServices.{i}.PhysicalMedium.{i}.
-Device.Services.StorageServices.{i}.StorageArray.{i}.
-Device.Services.StorageServices.Capabilities.FTPCapable
-Device.Services.StorageServices.Capabilities.HTTPCapable
-Device.Services.StorageServices.Capabilities.HTTPSCapable
-Device.Services.StorageServices.Capabilities.HTTPWritable
-Device.Services.StorageServices.Capabilities.SFTPCapable
-Device.Services.StorageServices.Capabilities.SupportedFileSystemTypes
-Device.Services.StorageServices.Capabilities.SupportedNetworkProtocols
-Device.Services.StorageServices.Capabilities.SupportedRaidTypes
-Device.Services.StorageServices.Capabilities.VolumeEncryptionCapable
-Device.Services.StorageServices.Enable
-Device.Services.StorageServices.LogicalVolume.{i}.Capacity
-Device.Services.StorageServices.LogicalVolume.{i}.Enable
-Device.Services.StorageServices.LogicalVolume.{i}.FileSystem
-Device.Services.StorageServices.LogicalVolume.{i}.FolderNumberOfEntries
-Device.Services.StorageServices.LogicalVolume.{i}.Name
-Device.Services.StorageServices.LogicalVolume.{i}.Status
-Device.Services.StorageServices.LogicalVolume.{i}.ThresholdLimit
-Device.Services.StorageServices.LogicalVolume.{i}.UsedSpace
-Device.Services.StorageServices.LogicalVolume.{i}.X_CATAWAMPUS-ORG_ReadOnly
-Device.Services.StorageServices.LogicalVolumeNumberOfEntries
-Device.Services.StorageServices.PhysicalMedium.{i}.Capacity
-Device.Services.StorageServices.PhysicalMedium.{i}.ConnectionType
-Device.Services.StorageServices.PhysicalMedium.{i}.FirmwareVersion
-Device.Services.StorageServices.PhysicalMedium.{i}.Health
-Device.Services.StorageServices.PhysicalMedium.{i}.HotSwappable
-Device.Services.StorageServices.PhysicalMedium.{i}.Model
-Device.Services.StorageServices.PhysicalMedium.{i}.Name
-Device.Services.StorageServices.PhysicalMedium.{i}.Removable
-Device.Services.StorageServices.PhysicalMedium.{i}.SMARTCapable
-Device.Services.StorageServices.PhysicalMedium.{i}.SerialNumber
-Device.Services.StorageServices.PhysicalMedium.{i}.Vendor
-Device.Services.StorageServices.PhysicalMediumNumberOfEntries
-Device.Services.StorageServices.StorageArrayNumberOfEntries
-Device.Services.StorageServices.UserAccountNumberOfEntries
-Device.Services.StorageServices.UserGroupNumberOfEntries
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.BadEraseBlocks
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.CorrectedErrors
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.EraseBlockSize
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.IOSize
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.MaxEraseCount
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.Name
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.ReservedEraseBlocks
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolume.{i}.DataBytes
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolume.{i}.Name
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolume.{i}.Status
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.SubVolumeNumberOfEntries
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.TotalEraseBlocks
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMedia.{i}.UncorrectedErrors
-Device.Services.StorageServices.X_CATAWAMPUS-ORG_FlashMediaNumberOfEntries
-Device.USB.
-Device.USB.Interface.{i}.
-Device.USB.Interface.{i}.Stats.
-Device.USB.Port.{i}.
-Device.USB.USBHosts.
-Device.USB.USBHosts.Host.{i}.
-Device.USB.USBHosts.Host.{i}.Device.{i}.
-Device.USB.USBHosts.Host.{i}.Device.{i}.Configuration.{i}.
-Device.USB.USBHosts.Host.{i}.Device.{i}.Configuration.{i}.Interface.{i}.
-Device.WiFi
-Device.WiFi.AccessPoint.{i}.
-Device.WiFi.AccessPoint.{i}.Accounting.
-Device.WiFi.AccessPoint.{i}.AssociatedDevice.{i}.
-Device.WiFi.AccessPoint.{i}.Security.
-Device.WiFi.AccessPoint.{i}.WPS.
-Device.WiFi.EndPoint.{i}.
-Device.WiFi.EndPoint.{i}.Profile.{i}.
-Device.WiFi.EndPoint.{i}.Profile.{i}.Security.
-Device.WiFi.EndPoint.{i}.Profile.{i}.WPS.
-Device.WiFi.EndPoint.{i}.Security
-Device.WiFi.EndPoint.{i}.Stats
-Device.WiFi.Radio.{i}.
-Device.WiFi.Radio.{i}.Antenna.
-Device.WiFi.Radio.{i}.Stats.
-Device.WiFi.SSID.{i}.
-Device.WiFi.SSID.{i}.Stats.
-InternetGatewayDevice.
-InternetGatewayDevice.DeviceConfig.
-InternetGatewayDevice.DeviceInfo.
-InternetGatewayDevice.DeviceInfo.AdditionalHardwareVersion
-InternetGatewayDevice.DeviceInfo.AdditionalSoftwareVersion
-InternetGatewayDevice.DeviceInfo.Description
-InternetGatewayDevice.DeviceInfo.HardwareVersion
-InternetGatewayDevice.DeviceInfo.Manufacturer
-InternetGatewayDevice.DeviceInfo.ManufacturerOUI
-InternetGatewayDevice.DeviceInfo.ModelName
-InternetGatewayDevice.DeviceInfo.ModemFirmwareVersion
-InternetGatewayDevice.DeviceInfo.ProductClass
-InternetGatewayDevice.DeviceInfo.SerialNumber
-InternetGatewayDevice.DeviceInfo.SoftwareVersion
-InternetGatewayDevice.DeviceInfo.SpecVersion
-InternetGatewayDevice.DeviceInfo.UpTime
-InternetGatewayDevice.DeviceInfo.VendorConfigFile.{i}.
-InternetGatewayDevice.DeviceInfo.VendorConfigFileNumberOfEntries
-InternetGatewayDevice.IPPingDiagnostics.
-InternetGatewayDevice.LANConfigSecurity.
-InternetGatewayDevice.LANDevice.{i}.
-InternetGatewayDevice.LANDevice.{i}.Hosts.
-InternetGatewayDevice.LANDevice.{i}.Hosts.Host.{i}.
-InternetGatewayDevice.LANDevice.{i}.LANEthernetInterfaceConfig.{i}.
-InternetGatewayDevice.LANDevice.{i}.LANEthernetInterfaceConfig.{i}.Stats.
-InternetGatewayDevice.LANDevice.{i}.LANEthernetInterfaceNumberOfEntries
-InternetGatewayDevice.LANDevice.{i}.LANHostConfigManagement.
-InternetGatewayDevice.LANDevice.{i}.LANHostConfigManagement.IPInterface.{i}.
-InternetGatewayDevice.LANDevice.{i}.LANUSBInterfaceConfig.{i}.
-InternetGatewayDevice.LANDevice.{i}.LANUSBInterfaceConfig.{i}.Stats.
-InternetGatewayDevice.LANDevice.{i}.LANUSBInterfaceNumberOfEntries
-InternetGatewayDevice.LANDevice.{i}.LANWLANConfigurationNumberOfEntries
-InternetGatewayDevice.LANDevice.{i}.WLANConfiguration.{i}.
-InternetGatewayDevice.LANDevice.{i}.WLANConfiguration.{i}.AssociatedDevice.{i}.
-InternetGatewayDevice.LANDevice.{i}.WLANConfiguration.{i}.PreSharedKey.{i}.
-InternetGatewayDevice.LANDevice.{i}.WLANConfiguration.{i}.WEPKey.{i}.
-InternetGatewayDevice.LANDeviceNumberOfEntries
-InternetGatewayDevice.Layer2Bridging.
-InternetGatewayDevice.Layer2Bridging.AvailableInterface.{i}.
-InternetGatewayDevice.Layer2Bridging.Bridge.{i}.
-InternetGatewayDevice.Layer2Bridging.Filter.{i}.
-InternetGatewayDevice.Layer2Bridging.Marking.{i}.
-InternetGatewayDevice.Layer3Forwarding.
-InternetGatewayDevice.Layer3Forwarding.Forwarding.{i}.
-InternetGatewayDevice.ManagementServer.
-InternetGatewayDevice.ManagementServer.ConnectionRequestPassword
-InternetGatewayDevice.ManagementServer.ConnectionRequestURL
-InternetGatewayDevice.ManagementServer.ConnectionRequestUsername
-InternetGatewayDevice.ManagementServer.DefaultActiveNotificationThrottle
-InternetGatewayDevice.ManagementServer.EnableCWMP
-InternetGatewayDevice.ManagementServer.ManageableDevice.{i}.
-InternetGatewayDevice.ManagementServer.ParameterKey
-InternetGatewayDevice.ManagementServer.Password
-InternetGatewayDevice.ManagementServer.PeriodicInformEnable
-InternetGatewayDevice.ManagementServer.PeriodicInformInterval
-InternetGatewayDevice.ManagementServer.PeriodicInformTime
-InternetGatewayDevice.ManagementServer.URL
-InternetGatewayDevice.ManagementServer.UpgradesManaged
-InternetGatewayDevice.ManagementServer.Username
-InternetGatewayDevice.PeriodicStatistics.MaxReportSamples
-InternetGatewayDevice.PeriodicStatistics.MinSampleInterval
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Enable
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.FetchSamples
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Name
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.CalculationMode
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Enable
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Failures
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.HighThreshold
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.LowThreshold
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Reference
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleMode
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SampleSeconds
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.SuspectData
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Parameter.{i}.Values
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ParameterNumberOfEntries
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ReportEndTime
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ReportSamples
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.ReportStartTime
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.SampleInterval
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.SampleSeconds
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.Status
-InternetGatewayDevice.PeriodicStatistics.SampleSet.{i}.TimeReference
-InternetGatewayDevice.PeriodicStatistics.SampleSetNumberOfEntries
-InternetGatewayDevice.QueueManagement.
-InternetGatewayDevice.QueueManagement.App.{i}.
-InternetGatewayDevice.QueueManagement.Classification.{i}.
-InternetGatewayDevice.QueueManagement.Flow.{i}.
-InternetGatewayDevice.QueueManagement.Policer.{i}.
-InternetGatewayDevice.QueueManagement.Queue.{i}.
-InternetGatewayDevice.Services.
-InternetGatewayDevice.Time.
-InternetGatewayDevice.Time.CurrentLocalTime
-InternetGatewayDevice.Time.Enable
-InternetGatewayDevice.Time.LocalTimeZoneName
-InternetGatewayDevice.UserInterface.
-InternetGatewayDevice.WANDevice.{i}.
-InternetGatewayDevice.WANDevice.{i}.WAN-CommonInterfaceConfig.WANAccessType
-InternetGatewayDevice.WANDevice.{i}.WAN-OpticalInterfaceConfig.
-InternetGatewayDevice.WANDevice.{i}.WAN-OpticalInterfaceConfig.Enable
-InternetGatewayDevice.WANDevice.{i}.WAN-OpticalInterfaceConfig.LowerOpticalThreshold
-InternetGatewayDevice.WANDevice.{i}.WAN-OpticalInterfaceConfig.LowerTransmitPowerThreshold
-InternetGatewayDevice.WANDevice.{i}.WAN-OpticalInterfaceConfig.OpticalSignalLevel
-InternetGatewayDevice.WANDevice.{i}.WAN-OpticalInterfaceConfig.Status
-InternetGatewayDevice.WANDevice.{i}.WAN-OpticalInterfaceConfig.TransmitOpticalLevel
-InternetGatewayDevice.WANDevice.{i}.WAN-OpticalInterfaceConfig.UpperOpticalThreshold
-InternetGatewayDevice.WANDevice.{i}.WAN-OpticalInterfaceConfig.UpperTransmitPowerThreshold
-InternetGatewayDevice.WANDevice.{i}.WANCommonInterfaceConfig.
-InternetGatewayDevice.WANDevice.{i}.WANCommonInterfaceConfig.Connection.{i}.
-InternetGatewayDevice.WANDevice.{i}.WANConnectionDevice.{i}.
-InternetGatewayDevice.WANDevice.{i}.WANConnectionDevice.{i}.WANEthernetLinkConfig.
-InternetGatewayDevice.WANDevice.{i}.WANConnectionDevice.{i}.WANIPConnection.{i}.
-InternetGatewayDevice.WANDevice.{i}.WANConnectionDevice.{i}.WANIPConnection.{i}.PortMapping.{i}.
-InternetGatewayDevice.WANDevice.{i}.WANConnectionDevice.{i}.WANIPConnection.{i}.Stats.
-InternetGatewayDevice.WANDevice.{i}.WANEthernetInterfaceConfig.
-InternetGatewayDevice.WANDevice.{i}.WANEthernetInterfaceConfig.Stats.
-InternetGatewayDevice.WANDeviceNumberOfEntries
-TraceRoute.
-TraceRoute.DSCP
-TraceRoute.DataBlockSize
-TraceRoute.DiagnosticsState
-TraceRoute.Host
-TraceRoute.Interface
-TraceRoute.MaxHopCount
-TraceRoute.NumberOfTries
-TraceRoute.ResponseTime
-TraceRoute.RouteHopsNumberOfEntries
-TraceRoute.Timeout
-VoiceService.{i}.
-VoiceService.{i}.Capabilities.
-VoiceService.{i}.Capabilities.Codecs.{i}.
-VoiceService.{i}.Capabilities.SIP.
-VoiceService.{i}.PhyInterface.{i}.
-VoiceService.{i}.PhyInterface.{i}.Tests.
-VoiceService.{i}.VoiceProfile.{i}.
-VoiceService.{i}.VoiceProfile.{i}.ButtonMap.
-VoiceService.{i}.VoiceProfile.{i}.ButtonMap.Button.{i}.
-VoiceService.{i}.VoiceProfile.{i}.FaxT38.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.CallingFeatures.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.Codec.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.Codec.List.{i}.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.Ringer.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.Ringer.Description.{i}.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.Ringer.Event.{i}.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.Ringer.Pattern.{i}.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.SIP.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.SIP.EventSubscribe.{i}.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.Session.{i}.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.Stats.
-VoiceService.{i}.VoiceProfile.{i}.Line.{i}.VoiceProcessing.
-VoiceService.{i}.VoiceProfile.{i}.NumberingPlan.
-VoiceService.{i}.VoiceProfile.{i}.NumberingPlan.PrefixInfo.{i}.
-VoiceService.{i}.VoiceProfile.{i}.RTP.
-VoiceService.{i}.VoiceProfile.{i}.RTP.RTCP.
-VoiceService.{i}.VoiceProfile.{i}.SIP.
-VoiceService.{i}.VoiceProfile.{i}.SIP.EventSubscribe.{i}.
-VoiceService.{i}.VoiceProfile.{i}.SIP.ResponseMap.{i}.
-VoiceService.{i}.VoiceProfile.{i}.ServiceProviderInfo.
-VoiceService.{i}.VoiceProfile.{i}.Tone.
-VoiceService.{i}.VoiceProfile.{i}.Tone.Description.{i}.
-VoiceService.{i}.VoiceProfile.{i}.Tone.Event.{i}.
-VoiceService.{i}.VoiceProfile.{i}.Tone.Pattern.{i}.
-X_CATAWAMPUS-ORG_CATAWAMPUS.
-X_CATAWAMPUS-ORG_CATAWAMPUS.RuntimeEnvInfo
-X_GOOGLE-COM_GFIBERTV.
-X_GOOGLE-COM_GFIBERTV.Mailbox.Name
-X_GOOGLE-COM_GFIBERTV.Mailbox.Node
-X_GOOGLE-COM_GFIBERTV.Mailbox.NodeList
-X_GOOGLE-COM_GFIBERTV.Mailbox.Value
-X_GOOGLE-COM_GVSB.
-X_GOOGLE-COM_GVSB.EpgPrimary
-X_GOOGLE-COM_GVSB.EpgSecondary
-X_GOOGLE-COM_GVSB.GvsbChannelLineup
-X_GOOGLE-COM_GVSB.GvsbKick
-X_GOOGLE-COM_GVSB.GvsbServer
diff --git a/dataModel.py b/dataModel.py
index 73adf5e..af45a0b 100755
--- a/dataModel.py
+++ b/dataModel.py
@@ -17,6 +17,29 @@
- Data Models for MoCA
- Data Models for TR140
- Data Models for TR181
+ 5. This file includes the following test cases:
+ (all data models test case are pending on bug: http://b/issue?id=6813492
+ SetParameterValues does not work currently)
+ - testID: 14165033 7.6.13 Support of Data Models for GVSB (TBD)
+ - testID: 14315008 7.6.14 Support of Data Models for TR098
+ - testID: 14165035 7.6.15 Support of Data Models for MoCA
+ - testID: 14187024 7.6.16 Support of Data Models for TR140
+ - testID: 14314007 7.6.17 Support of Data Models for TR181
+ - testID: 11865133 7.6.9.1 Support of Data Models: TR135
+ - testID: 14335001 7.6.31 Implement X_CATAWAMPUS-ORG parameters
+ - testID: 14319149 7.6.29 Implement X_GOOGLE-COM data model for Sage
+ information
+ - testID: 14314008 7.6.30 Implement tr-157 PeriodicStatistics
+
+ - testID: 14315009 7.6.20 Support of modification of
+ InternetGatewayDevice.ManagementServer.URL
+ - testID: 14314009 7.6.35 Monitor temperature
+ - testID: 14266498 7.6.36 X_CATAWAMPUS-ORG_FlashDevice Storage data
+ model (for tracking flash wear)
+ - testID: 14165038 7.6.37 Implement AutoChannelEnable in catawampus
+ - testID: 11722375 7.6.6 TR069 - SetParameter RPC Request
+ - testID: 15643845 7.6.39 NTP-Time zone configuration
+ - testID: 14165034 7.6.14.1 WiFi Test: ACS configuration
"""
__author__ = 'Lehan Meng (lmeng@google.com)'
@@ -49,21 +72,18 @@
info = self.log.CreateResultInfo(
'---', 'Data model verification test started...')
self.log.SendLine(self.test_info, info)
-
self.bruno = device.Bruno(user=self.params['user'],
addr=self.params['addr'],
pwd=self.params['pwd'],
cmd_prompt=self.params['bruno_prompt'])
- self.p_ssh = ssh.SSH(user=self.params['user'],
- addr=self.params['addr'],
- pwd=self.params['pwd'],
- bruno_prompt=self.params['bruno_prompt'],
- addr_ipv6=self.params['addr_ipv6'],
- athena_user=self.params['athena_user'],
- athena_pwd=self.params['athena_pwd'],
- jump_server=self.params['jump_server'])
- self.p_ssh.Setlogging(self.log)
- self.bruno.Setlogging(self.log)
+ if not self.p_ssh:
+ self.p_ssh = ssh.SSH(user=self.params['user'],
+ addr=self.params['addr'],
+ pwd=self.params['pwd'],
+ bruno_prompt=self.params['bruno_prompt'],
+ addr_ipv6=self.params['addr_ipv6'])
+ self.p_ssh.SetLogging(self.log)
+ self.bruno.SetLogging(self.log)
self.bruno.dev_ssh = self.p_ssh
self.__short_delay = 30 #short delay: 5 seconds
@@ -72,13 +92,53 @@
self.req_file = open(self.params['req_file'], 'r')
self.req_tr069_params = []
+ self.acs_instance = acs.ACS()
+ self.acs_instance.SetLogging(self.log)
+
+ def SetACSURL(self, url=None):
+ """Set the ACS URL on device."""
+ if not url:
+ url = self.params['acs_url']
+ self.p_ssh.SendCmd('echo '+ url + ' > /tmp/cwmp/acs_url')
+ self.p_ssh.GetCmdOutput()[1].rstrip()
+
+ def GetACSURL(self):
+ """Get ACS URL from Device."""
+ self.p_ssh.SendCmd(r'cat /tmp/cwmp/acs_url')
+ line = self.p_ssh.GetCmdOutput()[1].strip()
+ m = re.match('http[s]?://([\w-]+\.)+\.com/cwmp', line)
+ if m is None:
+ info = self.log.CreateErrorInfo('Warning',
+ 'Can not get ACS url')
+ self.log.SendLine(None, info)
+ else:
+ info = self.log.CreateProgressInfo('---',
+ 'Get ACS URL from device file: '
+ + line)
+ self.log.SendLine(None, info)
+ return line
+
+ def GetCurrentVersion(self):
+ """Get current software version."""
+ self.p_ssh.SendCmd('more /etc/version')
+ return self.p_ssh.GetCmdOutput()[1].strip()
def TestEnvCheck(self):
"""Verify device configuration meets the test requirement."""
- acs_url = self.bruno.GetACSUrl()
- self.AddConfigParams('acs_url', acs_url)
+ acs_url = self.GetACSURL()
+ if acs_url != self.params['acs_url']:
+ info = self.log.CreateErrorInfo(
+ 'Warning', 'ACS URL incorrect!. Expected: '
+ + self.params['acs_url'] + ', Current: '
+ + acs_url)
+ self.log.SendLine(self.test_info, info)
+ #os.sys.exit(1)
+ info = self.log.CreateProgressInfo(
+ '---', 'Reset ACS URL to Expected: ' + self.params['acs_url'])
+ self.log.SendLine(self.test_info, info)
+ self.SetACSURL()
- current_version = self.bruno.getCurrentVersion()
+ current_version = self.GetCurrentVersion()
if (not current_version
or current_version != self.params['expected_version']):
info = self.log.CreateErrorInfo(
@@ -122,28 +182,234 @@
new_list.append(line)
return (missing_list, new_list)
- def SetParameterValues(self, param='', value=''):
- """Set parameter values on Device."""
+ def GetACSAppFromURL(self):
+ """Parse ACS appID from ACS URL string."""
+ return re.sub(r'https?://(.*).appspot.com/cwmp', r'\1',
+ self.params['acs_url'])
+
+ def GetSerialNumber(self):
+ """This function returns Bruno device serial number."""
+ self.p_ssh.SendCmd('hnvram -r 1st_serial_number')
+ line = self.p_ssh.GetCmdOutput()[1].strip()
+ if line is None:
+ info = self.log.CreateErrorInfo('Warning',
+ 'Can not get serial number')
+ self.log.SendLine(None, info)
+ return False
+ return re.sub(r'1st_serial_number=([0-9A-Z]{12})', r'\1', line)
+
+ def GetProductClass(self):
+ """Get product class from device system."""
+ self.p_ssh.SendCmd('cat /etc/platform')
+ return self.p_ssh.GetCmdOutput()[1].strip()
+
+ def BatchSetParametersValues(self, tree, param):
+ """Set multiple parameter values in a single nbi_client RPC call.
+
+ Set multiple parameter values
+ Args:
+ tree: the parameter names are in TreeElement structure. It has
+ parameter 'writable' states and test_value to set.
+ Parameter names/paths are sorted in alphabetical order in tree.
+ param: the parameters name list that needs to be set with new value
+ """
nbi_path = self.params['nbi_client_path']
+ app_id = self.GetACSAppFromURL()
+ product_class = self.GetProductClass()
+ serial_no = self.GetSerialNumber()
+
+ container = tree.findall('parameter_value_struct')
+ batch_size = 1
+ counter = 0
+ parameter_struct = ''
+
+ for node in container:
+ name = node.findtext('name')
+
+ if name in param:
+ nbi_type = node.findtext('nbi_type')
+
+ if not nbi_type:
+ info = self.log.CreateErrorInfo('Warning',
+ 'Can not determin parameter type!')
+ self.log.SendLine(None, info)
+
+ test_value = node.findtext('test_value')
+ if nbi_type == 'string_value':
+ test_value = '"' + test_value + '"'
+ if (node.findtext('writable') == '1'
+ or node.findtext('writable') == 'true'):
+ parameter_struct += ('parameter_value_struct: <name: "'
+ + name + '" ' + nbi_type + ': '
+ + test_value + '> ')
+ counter += 1
+ else:
+ continue
+
+ if counter >= batch_size:
+ counter = 0
+ cmd = (nbi_path
+ + ' --server /gns/project/apphosting/stubby/prod-appengine/'
+ '*/' + app_id + '/default/* --service CpeParametersService '
+ '--method SetParameterValues --request \''
+ 'cpe_id: <oui: "F88FCA" product_class: "' + product_class
+ + '" serial_no: "' + serial_no
+ + '"> request: <parameter_list < '
+ + parameter_struct + ' > parameter_key: "myParamKey">\'')
+ print cmd
+ parameter_struct = ''
+ time_stamp = self.GetTimeStamp()
+ call_result = self.acs_instance.StubbyClientCall(cmd)
+ print call_result
+ if not self.acs_instance.CheckCmdCall(call_result):
+ # command not succeed according to nbi_client reply
+ # However, there is possibility that the request is successful,
+ # nbi_client reports a failure only because the timeout 60s.
+ # check device log to see if this request actually fails
+ self.p_ssh.SendCmd('dmesg | grep cwmpd:')
+ # read the last 500 lines from log
+ log_list = self.p_ssh.GetCmdOutput(500)
+ log_list.reverse()
+ reply_msg = self.ParseDeviceLogForError(
+ time_stamp, log_list, name, 'SetParameterValues')
+ if '<soap:Fault>' in reply_msg[0] or '<soap:fault>' in reply_msg[0]:
+ # failed to set parameter values (on nbi_client and device):
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Batch SetParameterValues() failed on Parameter: '
+ + name + '. Parameter type: ' + nbi_type
+ + '. Set test value: ' + test_value + '. Error message: \n'
+ + ''.join(reply_msg))
+ self.log.SendLines(self.test_info, info)
+ elif '<cwmp:SetParameterValuesResponse>' in reply_msg[0]:
+ # nbi_reports failure, but success on device
+ info = self.log.CreateResultInfo(
+ '---', 'Batch SetParameterValues() Succeeded on Parameter: '
+ + name + '. Parameter type: ' + nbi_type
+ + '. Set test value: ' + test_value)
+ self.log.SendLine(self.test_info, info)
+ else:
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Batch SetParameterValues() failed on Parameter: '
+ + name + '. Parameter type: ' + nbi_type
+ + '. Set test value: ' + test_value + '. Error message: \n'
+ + ''.join(reply_msg))
+ self.log.SendLines(self.test_info, info)
+ else:
+ # Succeed, logging to result file:
+ self.log.SendTestData(call_result)
+ info = self.log.CreateResultInfo(
+ '---', 'Batch SetParameterValues() Succeeded on Parameter: '
+ + name + '. Parameter type: ' + nbi_type
+ + '. Set test value: ' + test_value)
+ self.log.SendLine(self.test_info, info)
+
+ def SetParameterValues(self, param='', param_type='', value=''):
+ """Set parameter values on Device.
+
+ Set parameter values
+ Args:
+ param: the parameter name that needs to be set with new value
+ param_type: type of value: string, boolean, long_int, etc
+ value: parameter value
+ Returns:
+ return setParameterValues if succeeded.
+ return error information if failed
+ """
+ nbi_path = self.params['nbi_client_path']
+ app_id = self.GetACSAppFromURL()
+ product_class = self.GetProductClass()
+ serial_no = self.GetSerialNumber()
+ # parse type:
+ if 'string' in param_type:
+ param_type = 'string_value'
+ value = '"' + value + '"'
+ elif 'bool' in param_type:
+ param_type = 'boolean_value'
+ elif 'unsignedInt' in param_type:
+ param_type = 'long_value'
+ else:
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Unknown parameter type: ' + param_type)
+ self.log.SendLines(self.test_info, info)
+ os.sys.exit(1)
+
cmd = (nbi_path + ' --server /gns/project/apphosting/stubby/prod-appengine/'
- '*/gfiber-acs-staging/default/* --service CpeParametersService '
+ '*/' + app_id + '/default/* --service CpeParametersService '
'--method SetParameterValues --request \''
- 'cpe_id: <oui: "F88FCA" product_class: "GFMS100" serial_no: '
- '"110120906BDE"> request: <parameter_list < '
- 'parameter_value_struct: <name: "'
- + param +
- '" string_value: "' + value + '"> > parameter_key: "myParamKey">\'')
- acs_instance = acs.ACS()
- acs_instance.SetLogging(self.log)
- call_result = acs_instance.StubbyClientCall(cmd)
+ 'cpe_id: <oui: "F88FCA" product_class: "' + product_class
+ + '" serial_no: "' + serial_no + '"> request: <parameter_list < '
+ 'parameter_value_struct: <name: "' + param +
+ '" ' + param_type + ': ' + value
+ + '> > parameter_key: "myParamKey">\'')
+ print cmd
+ call_result = self.acs_instance.StubbyClientCall(cmd)
+ if 'FAILED' in call_result[0]:
+ info = self.log.CreateErrorInfo(
+ 'Warning', 'ACS failed on SetParameterValues query: ' + cmd)
+ self.log.SendLines(self.test_info, info)
+ return False
+ else:
+ print call_result
+ return call_result
+
+ def GetParameterNames(self, param='.', next_level=True):
+ """Get next level parameter names of the current queried parameter.
+
+ The next level parameter names will be output to result file
+ Due to the large number of parameter instances, parameters in the same
+ parameter family will be grouped together into a single nbi_client
+ RPC call (getParameterNames() call, this call will feedback the access
+ state information). In order to minimize the total processing time, as
+ well as the number of RPC calls to ACS appEngine. This will greatly
+ reduce the execution time.
+ Each getParameterNames call will be created as an individual thread.
+ And multiple calls are made in parallel.
+
+ Args:
+ param:
+ This is the parameter that is queried for its next level names
+ Note that currently GetParameterNames does not support multiple
+ parameter names in a query command. If parameter name is a dot,
+ and the next level is 'False', then device will return all
+ parameters under the queried parameter path
+ next_level:
+ if this parameter is True:
+ only the next level parameter names are returned
+ if this parameter is False:
+ all parameter in the requested parameter path will be returned
+ Returns:
+ return the nbi_client RPC call response. Response can be used to
+ parse for parameters' name, access attribute, etc.
+ """
+ nbi_path = self.params['nbi_client_path']
+ app_id = self.GetACSAppFromURL()
+ product_class = self.GetProductClass()
+ serial_no = self.GetSerialNumber()
+ if next_level:
+ next_level = 'true'
+ else:
+ next_level = 'false'
+ cmd = (nbi_path + ' --server /gns/project/apphosting/stubby/prod-appengine/'
+ '*/' + app_id + '/default/* --service CpeParametersService '
+ '--method GetParameterNames --request \''
+ 'cpe_id: <oui: "F88FCA" product_class: "' + product_class
+ + '" serial_no: "' + serial_no + '"> request: <parameter_path: "'
+ + param + '" next_level: ' + next_level + '>\'')
+ print cmd
+ call_result = self.acs_instance.StubbyClientCall(cmd)
if 'FAILED' in call_result[0]:
self.nbi_result = []
+ info = self.log.CreateErrorInfo(
+ 'Warning', 'ACS failed on GetParameterNames query: ' + cmd)
+ self.log.SendLines(self.test_info, info)
+ return False
else:
self.nbi_result = call_result
print call_result
+ return call_result
def GetParameterValues(self, param=''):
- """Get parameter value(s) from the data model tree.
+ """Make a Get parameter value(s) query at ACS to request the device.
This method get value(s) of the designated parameter(s)
Args:
@@ -156,28 +422,176 @@
This method returns a list of parameter values and record them to file.
"""
nbi_path = self.params['nbi_client_path']
+ if param == '.':
+ param = ''
+ app_id = self.GetACSAppFromURL()
+ product_class = self.GetProductClass()
+ serial_no = self.GetSerialNumber()
cmd = (nbi_path + ' --server /gns/project/apphosting/stubby/prod-appengine/'
- '*/gfiber-acs-staging/default/* --service CpeParametersService '
+ '*/' + app_id + '/default/* --service CpeParametersService '
'--method GetParameterValues --request \''
- 'cpe_id: <oui: "F88FCA" product_class: "GFMS100" serial_no: '
- '"110120906BDE"> request: <parameter_names: "' +param + '">\'')
- acs_instance = acs.ACS()
- acs_instance.SetLogging(self.log)
- call_result = acs_instance.StubbyClientCall(cmd)
+ 'cpe_id: <oui: "F88FCA" product_class: "' + product_class
+ + '" serial_no: "' + serial_no + '"> request: <parameter_names: "'
+ +param + '">\'')
+
+ print cmd
+ call_result = self.acs_instance.StubbyClientCall(cmd)
if 'FAILED' in call_result[0]:
self.nbi_result = []
+ info = self.log.CreateErrorInfo(
+ 'Warning', 'ACS failed on GetParameterValues query: ' + cmd)
+ self.log.SendLines(self.test_info, info)
+ return False
else:
self.nbi_result = call_result
print call_result
- return acs_instance.ParseParameterNames(call_result)
+ return call_result
- def GetParameterNamesFromDeviceLog(self, time_stamp, param=''):
- """Get TR069 data model parameters that are supported by current image."""
+ def FindEndofRequest(self, log_list, index, pattern):
+ """Find the end of a request string from device log.
+
+ Some times the close tag, for example: </cwmp:SetParameterValues> is
+ separated to two consecutive log lines, due to the line length limitation.
+ This method try to search the request closing tag on separate lines
+
+ Args:
+ log_list: the device log list.
+ index: the index of the line to search for tag
+ pattern: the closing tag that need to be searched in log file
+ Returns:
+ True: if pattern find in log
+ False: if pattern not find in log
+ """
+ if index >= len(log_list)-1:
+ if pattern in log_list[index]:
+ return True
+ else:
+ return False
+
+ s = re.sub(r'\[\s*\d*\.\d*\]\s*cwmpd:\s*(.*)', r'\1', log_list[index + 1])
+ s = log_list[index].strip() + s.strip()
+
+ if pattern in s:
+ return True
+ return False
+
+ def MatchParameterName(self, line, param_name, rpc):
+ """Match rpc request logs to a parameter name."""
+ if rpc == 'GetParameterNames':
+ m = re.search(r'.*<ParameterPath>(.*)</ParameterPath>.*', line)
+ if m is not None and param_name in m.group(1):
+ return True
+ else:
+ return False
+ elif rpc == 'GetParameterValues':
+ m = re.search(r'.*<cwmp:GetParameterValues>.*<ParameterNames.*>(.*)'
+ '</ParameterNames></cwmp:GetParameterValues>.*', line)
+ if m is not None and param_name in m.group(1):
+ return True
+ else:
+ return False
+ elif rpc == 'SetParameterValues':
+ m = re.search(r'.*<Name>(.*)</Name><Value.*', line)
+ if m is not None and param_name in m.group(1):
+ return True
+ else:
+ return False
+ else:
+ return False
+
+ def ParseDeviceLogForError(self, time_stamp, log_list, param, rpc):
+ """Parse the log information from device, Looking for cwmp errors.
+
+ Args:
+ time_stamp: looking for log events that happened only after this time
+ log_list: the cwmp event information obtained from device log
+ param: the parameter name to get value from
+ rpc: the rpc function name to search in log
+ Returns:
+ return cwmp error message found in device log.
+ """
+
+ reply_msg = []
+ start_of_rpc_reply = False
+ end_of_rpc_reply = False
+ start_of_rpc_request = False
+ end_of_rpc_request = False
+ param_matching = False
+ current_index = 0
+
+ for line in log_list:
+ # check only the getParameter query starts after the specified time:
+ if float(self.GetTimeStamp(line)) > float(time_stamp):
+ if 'CPE RECEIVED (at' in line and not start_of_rpc_request:
+ index = log_list.index(line)
+ # macthing the request query in log messages
+ for i in range(index+1, len(log_list)-1):
+ if i < len(log_list):
+ # match rpc request string
+ if '<cwmp:' + rpc + '>' in log_list[i]:
+ start_of_rpc_request = True
+ # match rpc request string end
+ if (self.FindEndofRequest(log_list, i, '</cwmp:' + rpc + '>')
+ and start_of_rpc_request):
+ if (start_of_rpc_request and end_of_rpc_request
+ and not param in log_list[i]):
+ end_of_rpc_request = True
+ # rpc request scan completed, requested parameter not matched
+ # this request is not request of interest
+ start_of_rpc_request = False
+ end_of_rpc_request = False
+ break
+ # match queried parameter in rpc request
+ if start_of_rpc_request and not end_of_rpc_request:
+ if self.MatchParameterName(log_list[i], param, rpc):
+ param_matching = True
+ current_index = i
+ break
+
+ # search for end of rpc request command
+ if param_matching and not end_of_rpc_request:
+ for i in range(current_index, len(log_list)-1):
+ if i < len(log_list):
+ # match rpc request string end
+ if self.FindEndofRequest(log_list, i, '</cwmp:' + rpc + '>'):
+ end_of_rpc_request = True
+ current_index = i
+ break
+
+ # search for rpc request reply message
+ if param_matching and end_of_rpc_request:
+ for i in range(current_index, len(log_list)-1):
+ if i < len(log_list):
+ if ('<soap:Fault>' in log_list[i] or '<soap:fault>' in log_list[i]
+ or '<cwmp:' + rpc + 'Response>' in log_list[i]):
+ start_of_rpc_reply = True
+ if (' </soap:Fault>' in log_list[i]
+ or ' </soap:fault>' in log_list[i]
+ or '</cwmp:' + rpc + 'Response>' in log_list[i]):
+ end_of_rpc_reply = True
+ reply_msg.append(log_list[i].strip()+'\n')
+ if start_of_rpc_reply and not end_of_rpc_reply:
+ reply_msg.append(log_list[i].strip()+'\n')
+ if start_of_rpc_reply and end_of_rpc_reply:
+ return reply_msg
+ return ['No rpc message is available in device log']
+
+ def GetParameterListFromDeviceLog(self, time_stamp, param=''):
+ """Parse TR069 data model parameters from Device log information.
+
+ Args:
+ time_stamp: looking for log events that happened only after this time
+ param: the cwmp parameter to search in device log
+ Returns:
+ return parameter list if succeeded
+ return false otherwise
+ """
+ if param == '.':
+ param = ''
param_list = []
param_list_start = False
param_list_end = False
self.device_log_result = []
- num_of_params = 0
self.p_ssh.SendCmd('dmesg | grep cwmpd:')
log_list = self.p_ssh.GetCmdOutput()
@@ -188,15 +602,15 @@
if float(self.GetTimeStamp(line)) > float(time_stamp):
if '<cwmp:GetParameterValues>' in line:
# check the parameter query from nbi_client has been answered:
- m = re.search(r'.*<cwmp:GetParameterValues>.*<ParameterNames.*/>(.*)'
+ m = re.search(r'.*<cwmp:GetParameterValues>.*<ParameterNames.*>(.*)'
'</ParameterNames></cwmp:GetParameterValues>.*', line)
- if m is not None:
- output = re.sub(r'.*<cwmp:GetParameterValues>.*<ParameterNames.*/>'
- '(.*)</ParameterNames></cwmp:GetParameterValues>.*',
- r'\1', line)
- if output.strip() == param:
- param_list_start = True
- continue
+ if m is not None and param in m.group(1):
+ index = log_list.index(line)
+ for i in range(index+1, index+50):
+ if '<cwmp:GetParameterValuesResponse>' in log_list[i]:
+ param_list_start = True
+ break
+ continue
if '</cwmp:GetParameterValuesResponse>' in line:
if param_list_start:
@@ -206,7 +620,6 @@
if param_list_start:
self.device_log_result.append(line.strip())
if '<Name>' in line:
- num_of_params += 1
output = re.sub(r'.*(<Name>)(.*)(</Name>)', r'\2', line)
output = output.strip()
output = re.sub(r'(\.)[\d]+(\.)', r'\1{i}\2', output)
@@ -214,16 +627,31 @@
param_list.append(output)
if (not param_list_start) or (not param_list_end):
- return False
+ error_msg = self.ParseDeviceLogForError(
+ time_stamp, log_list, param, 'GetParameterValues')
+ if 'fault' in error_msg[0] or 'Fault' in error_msg[0]:
+ # error occurred in rpc request
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Exit! Error while get values: ' + ''.join(error_msg))
+ self.log.SendLines(self.test_info, info)
+ os.sys.exit(1)
+ else:
+ # no error in request, request still in progress
+ return False
return param_list
- def CreateElement(self, param_name, param_type, param_value):
+ def CreateElement(self, param_name, param_type_device,
+ param_type_nbi, param_value):
"""Create a new parameter node that contains parameter name and value.
- Currently try to set the same value as being read from the device
+ Currently try to set the same value as being read from the device.
+ Parameter type may have different representations on different platforms.
+ E.g.: type 'long_value' on nbi_client is 'unsignedInt' on bruno.
+ type 'string_value' on nbi_client is 'string' on bruno
Args:
param_name: the name of the parameter (Path)
- param_type: the type of the parameter
+ param_type_device: the type of the parameter represented by device format
+ param_type_nbi: the type of parameter, represented by nbi_client format
param_value: the value of the parameter
Returns:
return the created element node
@@ -232,33 +660,78 @@
name = ET.Element('name')
name.text = param_name
e.append(name)
- value = ET.Element('value', type=param_type)
+ device_type = ET.Element('device_type')
+ device_type.text = param_type_device
+ e.append(device_type)
+ nbi_type = ET.Element('nbi_type')
+ if not param_type_nbi:
+ if param_type_device == 'unsignedInt':
+ param_type_nbi = 'long_value'
+ elif param_type_device == 'boolean':
+ param_type_nbi = 'boolean_value'
+ elif param_type_device == 'string':
+ param_type_nbi = 'string_value'
+ else:
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Exit! Unknown (new) Parameter types found from device:'
+ ': ' + param_type_device + '. Define as string_value')
+ self.log.SendLine(self.test_info, info)
+ param_type_nbi = 'string_value'
+ nbi_type.text = param_type_nbi
+ e.append(nbi_type)
+ value = ET.Element('value')
value.text = param_value
e.append(value)
- test_value = ET.Element('test_value', type=param_type)
+ test_value = ET.Element('test_value')
test_value.text = param_value
e.append(test_value)
+ access_state = ET.Element('writable')
+ access_state.text = 'true'
+ e.append(access_state)
return e
+ def SortElementTree(self, tree):
+ """Sort the parameters in element tree, in alphabetical order of names.
+
+ Args:
+ tree: the ElementTree data structure that holds the parameter list
+ Returns:
+ return the sorted tree data structure
+ """
+ data = []
+ container = tree.findall('parameter_value_struct')
+ for node in container:
+ key = node.findtext('name')
+ data.append((key, node))
+
+ root = ET.Element(tree.getroot().tag, tree.getroot().attrib)
+ root.text = tree.getroot().text
+ data.sort()
+ for node in data:
+ root.append(node[1])
+ return ET.ElementTree(root)
+
def ParseToElementTree(self):
"""Parse the parameter list to Element Tree structure."""
root = ET.Element('Bruno_Automation_Test', name='Set_Parameter_Value_Test',
testCases=self.test_info['testID'])
root.text = 'This structure stores all parameters and values for this test'
- if self.nbi_result != []:
+ if self.nbi_result:
for line in self.nbi_result:
if 'name:' in line:
param_name = re.sub('.*\"(.*)\".*', r'\1', line).strip()
index = self.nbi_result.index(line)
param_type = self.nbi_result[index+1].split(':')[0].strip()
param_value = self.nbi_result[index+1].split(':')[1].strip()
- root.append(self.CreateElement(param_name, param_type, param_value))
- elif self.device_log_result != []:
+ root.append(self.CreateElement(param_name, None,
+ param_type, param_value))
+ elif self.device_log_result:
#self.device_log_result.reverse()
for line in self.device_log_result:
if '<Name>' in line:
param_name = re.sub(r'.*(<Name>)(.*)(</Name>)', r'\2', line).strip()
+
index = self.device_log_result.index(line) + 1
while not 'Value' in self.device_log_result[index]:
index += 1
@@ -269,36 +742,93 @@
return False
line = self.device_log_result[index]
- param_type = re.sub('.*type\w*=\w*\".*:(.*)\".*', r'\1', line).strip()
- param_value = re.sub('.*<.*type.*>(.*)</Value>', r'\1', line).strip()
- root.append(self.CreateElement(param_name, param_type, param_value))
+ # In case value string spans multiple lines:
+ while '</Value>' not in line:
+ index +=1
+ if index >= len(self.device_log_result):
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Exit! Cannot find matching </Value> tag in log!')
+ self.log.SendLine(self.test_info, info)
+ os.sys.exit(1)
+ new_line = self.device_log_result[index]
+ # if <Name> or EOF reached before a matching </Value> is found
+ if '<Name>' in new_line:
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Exit! Cannot find matching </Value> tag in log!')
+ self.log.SendLine(self.test_info, info)
+ os.sys.exit(1)
+ new_line = re.sub('\[\s*\d*\.\d{3}\]\s*cwmpd:\s*(.*)',
+ r'\1', new_line).strip()
+ line += new_line.strip()
+
+ param_type = re.search('.*type\s*=\s*\"[a-zA-Z]*:([a-zA-Z]*)\">.*',
+ line, re.DOTALL).group(1)
+ param_value = re.search('.*<Value\s*[a-zA-Z]*:type="[a-zA-Z]*:'
+ '[a-zA-Z]*">(.*)</Value>',
+ line, re.DOTALL).group(1)
+ root.append(self.CreateElement(param_name, param_type,
+ None, param_value))
else:
info = self.log.CreateErrorInfo(
'Critical', 'Failed to get parameter list from device!')
self.log.SendLine(self.test_info, info)
return False
+
tree = ET.ElementTree(root)
- fout = open(self.params['para_tree_file'], 'w')
- tree.write(fout)
- fout.close()
+ tree = self.SortElementTree(tree)
return tree
- def VerifyParameterValues(self, param=None):
- """Verify the designated parameter can be set with expected value.
+ def ParametersFromXMLFile(self, file_path=None):
+ """Read parameter data from an XML format file.
- Test results will be written to XML formated file, with test value
- that has been set for the parameter(s)
- For those parameters that failed to set value, they are recorded in
- the result file specified by self.log instance.
Args:
- param:
- 1. if parameter is given, this method will set the value of this
- parameter
- 2. if the parameter is not given, this method will set all parameters
- that the device currently supports
+ file_path: file path to the xml file
+ Returns:
+ return the parameter list stored in the file, in the format of ElementTree
"""
- self.para_tree = self.ParseToElementTree()
- self.SetParameterValues(param, 'none')
+ f = None
+ try:
+ if not file_path:
+ f = open(self.params['para_tree_file'], 'r')
+ else:
+ f = open(file_path, 'r')
+ tree = ET.parse(f)
+ except IOError, inst:
+ err_string = ('Exit! Unexpected error opening '
+ + str(f.name) + '. ' + str(inst))
+ info = self.log.CreateErrorInfo('Critical', err_string)
+ self.log.SendLine(self.test_info, info)
+ os.sys.exit(1)
+ return tree
+
+ def ParametersToXMLFile(self, tree=None, file_path=None):
+ """Output the available parameter instance tree to XML format file.
+
+ Parameter instance results will be written to XML formated file,
+ with test value that has been set for the parameter(s)
+ For those parameters that failed to set value, they are recorded in
+ the result file.
+
+ Args:
+ tree: the parameters structure to parse to file
+ file_path: path to the output file
+ """
+ if not tree:
+ tree = self.para_tree
+ if not file_path:
+ fout = open(self.params['para_tree_file'], 'w')
+ else:
+ fout = open(file_path, 'w')
+
+ try:
+ tree.write(fout)
+ except IOError, inst:
+ err_string = ('Exit! Unexpected error writing to file '
+ + fout.name() + str(inst))
+ info = self.log.CreateErrorInfo('Critical', err_string)
+ self.log.SendLine(self.test_info, info)
+ os.sys.exit(1)
+ fout.close()
def GetRequirementFromFile(self):
"""Get TR69 data model parameters from requirement file.
@@ -359,60 +889,59 @@
# Match, return the time stamp
return m.group(1)
# No time stamp found
- return -1
-
- #################### for Data Model Test Case ####################
- def Run(self):
- """Run the test case."""
- ####### Add your code here -- BEGIN #######
- print 'Test Started...'
- self.Init()
- self.p_ssh.SshRetry(5, 15)
- #self.p_ssh.SshToAthena()
- info = self.log.CreateProgressInfo(
- '5%', 'SSH session to Athena server successfully established!')
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Cannot get time information from Device log!')
self.log.SendLine(self.test_info, info)
+ os.sys.exit(1)
- #self.p_ssh.SshRetryFromAthena()
- #info = self.log.CreateProgressInfo(
- # '15%', 'SSH session to Device successfully established!')
- #self.log.SendLine(self.test_info, info)
+ def VerifyAllReqParameters(self):
+ """Check available parameters and compare to requirement list.
- #check device profile/image is as erquired management url from ACS
- self.TestEnvCheck()
+ This method checks all available parameters on current image, and
+ compare the list with requirement list. It will find out:
+ 1. the parameters that are missing from the requirement list.
+ 2. the newly added parameters that are not in the requirement list.
+ Both lists are written to the result file.
+
+ This method also output all parameter instances on current device to
+ a xml formated file, together with their types and values
+ """
+ # get parameter name lists, compare with requirement list
info = self.log.CreateProgressInfo(
- '25%', 'Check device test setup completed!')
- self.log.SendLine(self.test_info, info)
-
- # get parameter name lists, compare with requirement
- info = self.log.CreateProgressInfo(
- '35%', 'Get parameters from nbi_client ...')
+ '30%', 'Get parameters from nbi_client ...')
self.log.SendLine(self.test_info, info)
time_stamp = self.GetTimeStamp()
- if time_stamp == -1:
- info = self.log.CreateErrorInfo(
- 'Critical', 'Cannot get time information from Device log!')
- self.log.SendLine(self.test_info, info)
- os.sys.exit(1)
- chk_list = self.GetParameterValues()
+ chk_list = self.acs_instance.ParseParameterNames(self.GetParameterValues(),
+ True)
if not chk_list:
info = self.log.CreateProgressInfo(
- '40%', 'Get parameters from device log ...')
+ '35%', 'ACS failed to reply, get parameters from device log ...')
self.log.SendLine(self.test_info, info)
# nbi client may fail because of timeout
- # then get parameter list from device log
+ # if that is the case, then get parameter list from device log
+ count = 0
while not chk_list:
time.sleep(self.__delay)
- chk_list = self.GetParameterNamesFromDeviceLog(time_stamp)
+ chk_list = self.GetParameterListFromDeviceLog(time_stamp)
+ count += 1
+ if count*self.__delay >= self.__long_delay:
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Can not retrieve complete log info from device')
+ self.log.SendLine(self.test_info, info)
+ os.sys.exit(1)
+
+ if not chk_list:
+ info = self.log.CreateProgressInfo(
+ '40%', 'GetParameterValue query in progress, retry after '
+ + str(self.__delay) + ' seconds.')
+ self.log.SendLine(self.test_info, info)
chk_list.sort()
- if not chk_list:
- info = self.log.CreateErrorInfo(
- 'Critical', 'Cannot find parameter list requirement from log file!')
- self.log.SendLine(self.test_info, info)
- os.sys.exit(1)
-
+ info = self.log.CreateProgressInfo(
+ '55%', 'GetParameterValue query completed, verify parameter list '
+ 'with parameter requirement document.')
+ self.log.SendLine(self.test_info, info)
req_list = self.GetRequirementFromFile()
(mis_list, new_list) = self.CheckRequirement(chk_list, req_list)
mis_list.sort()
@@ -422,24 +951,465 @@
self.log.SendTestData(['############ Newly Added Parameters ############'])
self.log.SendTestData(new_list)
+
info = self.log.CreateProgressInfo(
- '50%', 'Get parameter names completed. Check '
- + self.log.params['f_result'] + ' file for missing parameters.')
+ '75%', 'Verify current parameter list with requirement completed. '
+ 'Check result file:' + self.log.params['f_error'] + ' for details.')
self.log.SendLine(self.test_info, info)
- # TODO(lmeng):
- #set parameter values:
- #self.VerifyParameterValues('X_GOOGLE-COM_GVSB.GvsbKick')
- #info = self.log.CreateProgressInfo(
- # '60%', 'Set parameter values completed. Check '
- # + self.log.params['f_result'] + ' file for missing parameters.')
- #self.log.SendLine(self.test_info, info)
+ # write parameter instance to file
+ self.para_tree = self.ParseToElementTree()
+ self.ParametersToXMLFile()
+ info = self.log.CreateProgressInfo(
+ '100%', 'Update parameter file: ' + self.params['para_tree_file']
+ + ' completed.')
+ self.log.SendLine(self.test_info, info)
+ info = self.log.CreateResultInfo(
+ 'Pass', 'Verification completed. '
+ 'Check result file: ' + self.log.params['f_result'] + ' for missing '
+ 'parameters and new parameters.')
+ self.log.SendLine(self.test_info, info)
- #self.SetParameterValues('X_GOOGLE-COM_GVSB.GvsbKick', 'arp')
- #self.GetParameterValues('X_GOOGLE-COM_GVSB.GvsbKick')
- #self.SetParameterValues('X_GOOGLE-COM_GVSB.GvsbKick', 'none')
- #self.GetParameterValues('X_GOOGLE-COM_GVSB.GvsbKick')
- #self.p_ssh.ExitToAthena()
+ def GetParameterAccessStateFromDeviceLog(self, time_stamp=None, param='.'):
+ """Get parameter access state from device logs.
+
+ Args:
+ time_stamp: search events only after this time in log file
+ param: the parameter to search in device log
+ Returns:
+ return dictionary: parameter names as key, and writable status as value
+ """
+ self.p_ssh.SendCmd('dmesg | grep cwmpd:')
+ log_list = self.p_ssh.GetCmdOutput()
+ log_list.reverse()
+
+ param_state_dict = {}
+ param_list_start = False
+ param_list_end = False
+
+ for line in log_list:
+ # check only the getParameter query starts after the last known event:
+ if float(self.GetTimeStamp(line)) > float(time_stamp):
+ if '<cwmp:GetParameterNames>' in line:
+ # check the parameter query from nbi_client has been answered:
+ m = re.search(
+ r'.*<cwmp:GetParameterNames>.*<ParameterPath>(.*)'
+ '</ParameterPath>.*<NextLevel>false</NextLevel>.*'
+ '</cwmp:GetParameterNames>.*', line)
+ if m and param in line:
+ index = log_list.index(line)
+ for i in range(index+1, index+30):
+ if i < len(log_list):
+ if '<cwmp:GetParameterNamesResponse>' in log_list[i]:
+ param_list_start = True
+ break
+ continue
+
+ if '</cwmp:GetParameterNamesResponse>' in line:
+ if param_list_start:
+ param_list_end = True
+ break
+
+ if param_list_start:
+ if '<Name>' in line:
+ name = re.search(r'.*<Name>(.*)</Name>', line).group(1).strip()
+ index = log_list.index(line)+1
+ if '<Writable>' in log_list[index]:
+ access = re.sub(r'.*<Writable>(.*)</Writable>',
+ r'\1', log_list[index]).strip()
+ if access == '1':
+ access = 'true'
+ else:
+ access = 'false'
+ param_state_dict.update({name: access})
+
+ if (not param_list_start) or (not param_list_end):
+ error_msg = self.ParseDeviceLogForError(
+ time_stamp, log_list, param, 'GetParameterNames')
+ if 'fault' in error_msg[0] or 'Fault' in error_msg[0]:
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Exit! Error while get values: ' + ''.join(error_msg))
+ self.log.SendLines(self.test_info, info)
+ os.sys.exit(1)
+ else:
+ return False
+ return param_state_dict
+
+ def UpdateParameterAccessState(self, tree, param_name='.'):
+ """Update parameters' access state (read-only, read-write status).
+
+ TR69 parameters could be either in a read-only state, or a writable
+ state. The setParameterValues() test only verifies those parameters
+ in the 'writable' state. Try to set them with new values.
+ This method is called to determine the state of each supported parameter
+
+ Args:
+ tree:
+ the ElementTree data structure that holds the parameter attribute
+ list in XML format. This tree needs to be sorted before passed to
+ this function, according to the alphabetical order of parameter
+ names.
+ param_name:
+ the parameter name to update the access state
+ Returns:
+ returns this tree with updated parameter access state information
+ """
+ time_stamp = self.GetTimeStamp()
+ cmd_list = self.GetParameterNames(param_name, False)
+ if not self.acs_instance.CheckCmdCall(cmd_list):
+ info = self.log.CreateProgressInfo(
+ '---', 'GetParameterNames() query failed on ACS. Analyzing device'
+ ' logs...')
+ self.log.SendLine(self.test_info, info)
+
+ param_dict = self.GetParameterAccessStateFromDeviceLog(time_stamp,
+ param_name)
+ while not param_dict:
+ info = self.log.CreateProgressInfo(
+ '---', 'GetParameterNames() analyze in progress, wait for '
+ + str(self.__short_delay) + ' seconds.')
+ self.log.SendLine(self.test_info, info)
+ time.sleep(self.__short_delay)
+ param_dict = self.GetParameterAccessStateFromDeviceLog(time_stamp,
+ param_name)
+ else:
+ param_dict = self.acs_instance.ParseParameterAccessStates(cmd_list)
+ for key in param_dict.keys():
+ if param_name.endswith('.') and param_name != '.':
+ param_dict[param_name + key] = param_dict.pop(key)
+ else:
+ param_dict[param_name + '.' + key] = param_dict.pop(key)
+
+ container = tree.findall('parameter_value_struct')
+
+ for node in container:
+ name = node.findtext('name')
+ if name in param_dict.keys():
+ e = node.find('writable')
+ if not e:
+ # Create this tag:
+ e = ET.Element('writable')
+ e.text = param_dict[name]
+ node.append(e)
+ else:
+ e.text = param_dict[name]
+ else:
+ continue
+ return tree
+
+ def MarkParametersToSet(self, param_list, param):
+ """In the sorted tree, mark all parameters before param to read-only."""
+ if not param:
+ return param_list
+
+ ls = list(param_list)
+ for name in param_list:
+ if name != param:
+ ls.remove(name)
+ else:
+ break
+ return ls
+
+ def VerifySetAllParameterValues(self):
+ """This verifies the setParameterValues() on all supported parameters.
+
+ This method tests the 'set' capability on all parameters. According
+ to the data type, the value will be set as 'string', 'long_int', 'boolean',
+ etc. Note the current test only verify the 'set' action is supported by
+ each parameter. Therefore, it will try to set the same default value on each
+ parameter (it does not change the default value of each parameter).
+
+ This test assumes that the parameter list has already been retrieved from
+ device by 'GetparameterValues', and has been written to the parameter XML
+ file.
+ """
+ tree = self.ParametersFromXMLFile()
+ #tree = self.UpdateParameterAccessState(tree)
+ tree = self.SortElementTree(tree)
+ param_list = []
+ # Currently Assume all parameters are read-write
+ container = tree.findall('parameter_value_struct')
+
+ for node in container:
+ #name = node.findtext('name')
+ #test_value = node.findtext('test_value')
+ dev_type = node.findtext('device_type')
+ nbi_type = None
+ if dev_type == 'unsignedInt':
+ nbi_type = 'long_value'
+ elif dev_type == 'boolean':
+ nbi_type = 'boolean_value'
+ elif dev_type == 'string':
+ nbi_type = 'string_value'
+ else:
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Exit! Unknown (new) Parameter types found from device:'
+ ': ' + dev_type)
+ self.log.SendLine(self.test_info, info)
+ os.sys.exit(1)
+ node.find('nbi_type').text = nbi_type
+ param_list.append(node.findtext('name'))
+ e = node.find('writable')
+ if not e:
+ access_state = ET.Element('writable')
+ access_state.text = 'true'
+ node.append(access_state)
+ param_list.sort()
+ param_list = self.MarkParametersToSet(
+ param_list, self.params['from_which_param_to_set'])
+ self.BatchSetParametersValues(tree, param_list)
+
+ def VerifyNTPTimeZoneConfig(self):
+ """Verify the Time zone configuration is received and processed by Device.
+
+ Check the log of device, to find TR69 parameter:
+ InternetGatewayDevice.Time.
+ is pushed down to device. Also verify the device correctly updated local
+ time information.
+ """
+ ## Blocked by bug: http://b/issue?id=6804551
+ ## TODO(lmeng): add set values and verify set values succeeded
+ self.p_ssh.SendCmd('dmesg | grep cwmpd:')
+ log_list = self.p_ssh.GetCmdOutput()
+ time_stamp = self.GetTimeStamp()
+ log_list = self.ParseDeviceLogForError(time_stamp, log_list,
+ 'InternetGatewayDevice.Time',
+ 'SetParameterValues')
+ if 'No rpc message is available in device log' in log_list[0]:
+ info = self.log.CreateResultInfo(
+ '---', 'Failed. Can not find TR69 Time zone information in device log')
+ self.log.SendLine(self.test_info, info)
+ elif 'fault' in log_list[0]:
+ info = self.log.CreateResultInfo(
+ '---', 'Failed to apply Time zone configuration on device.')
+ self.log.SendLine(self.test_info, info)
+ else:
+ info = self.log.CreateResultInfo(
+ '---', 'Succeed to setup Time zone on deivce.')
+ self.log.SendLine(self.test_info, info)
+
+ def VerifyManagementServerURL(self):
+ """Verify set and get Management Server URL from device."""
+ # This test is blocked by bug: http://b/issue?id=6813492
+ mngmt_url_param = 'InternetGatewayDevice.ManagementServer.URL'
+ url_from_dev_param = self.acs_instance.ParseManagementURL(
+ self.GetParameterValues(mngmt_url_param))
+ info = self.log.CreateProgressInfo(
+ '15%', 'Get management url from TR069 parameter: '
+ + mngmt_url_param + '. Value: ' + url_from_dev_param)
+ self.log.SendLine(self.test_info, info)
+ if not url_from_dev_param:
+ info = self.log.CreateProgressInfo(
+ '30%', 'Can not found Value for: '
+ 'InternetGatewayDevice.ManagementServer.URL'
+ '. Verify to set default URL: ' + self.params['default_url'])
+ self.log.SendLine(self.test_info, info)
+ url_from_dev_param = self.params['default_url']
+
+ info = self.log.CreateProgressInfo(
+ '50%', 'Set parameter value for: '
+ 'InternetGatewayDevice.ManagementServer.URL'
+ '. Value: ' + url_from_dev_param)
+ self.log.SendLine(self.test_info, info)
+ result = self.SetParameterValues(mngmt_url_param, 'string',
+ url_from_dev_param)
+ if not result:
+ info = self.log.CreateErrorInfo(
+ 'Critical', 'Failed to set parameter: '
+ 'InternetGatewayDevice.ManagementServer.URL')
+ self.log.SendLine(self.test_info, info)
+ info = self.log.CreateResultInfo(
+ 'Failed', 'Failed to set parameter: '
+ 'InternetGatewayDevice.ManagementServer.URL')
+ self.log.SendLine(self.test_info, info)
+ else:
+ info = self.log.CreateProgressInfo(
+ '100%', 'Succeeded to set parameter: '
+ 'InternetGatewayDevice.ManagementServer.URL')
+ self.log.SendLine(self.test_info, info)
+ info = self.log.CreateResultInfo(
+ 'Pass', 'Succeeded to set parameter: '
+ 'InternetGatewayDevice.ManagementServer.URL')
+ self.log.SendLine(self.test_info, info)
+
+ def VerifySetParameterValuesRPC(self):
+ """Test case: 11722375. To verify SetParameterValues RPC.
+
+ To verify SetParametersRPC, this methond also try to set all parameters
+ which have 'write-able' status, with test value.
+ """
+ # update parameter access state:
+ info = self.log.CreateProgressInfo(
+ '20%', 'Read Parameters read/write status from file.')
+ self.log.SendLine(self.test_info, info)
+ tree = self.ParametersFromXMLFile()
+ info = self.log.CreateProgressInfo(
+ '50%', 'Update parameters read/write status from Device.')
+ self.log.SendLine(self.test_info, info)
+ tree = self.UpdateParameterAccessState(tree, self.params['param_path'])
+ self.ParametersToXMLFile(tree)
+ # set parameter values:
+ self.VerifySetAllParameterValues()
+ info = self.log.CreateProgressInfo(
+ '100%', 'Verify: Set values for all parameters completed.')
+ self.log.SendLine(self.test_info, info)
+ info = self.log.CreateResultInfo(
+ 'Pass', 'Verification: set parameter '
+ 'values completed. '
+ 'Check result file: ' + self.log.params['f_result'] + ' for details.')
+ self.log.SendLine(self.test_info, info)
+
+ def VerifyMonitorTemperature(self):
+ """Test the temperature monitor on device.
+
+ This feature is not available for first launch.
+ """
+ info = self.log.CreateResultInfo(
+ 'Block', 'This feature is not availalbe '
+ 'on the first launch images.')
+ self.log.SendLine(self.test_info, info)
+
+ def VerifyAutoChannelEnable(self):
+ """Test AutoChannelEnable on device.
+
+ This feature is not available for first launch.
+ """
+ info = self.log.CreateResultInfo(
+ 'Block', 'This feature is not availalbe '
+ 'on the first launch images.')
+ self.log.SendLine(self.test_info, info)
+
+ def SetServiceConfigs(self, param_dict):
+ """Set service parameter profile on ACS.
+
+ This method sets the service configurations on ACS, and returns the
+ SetServiceConfigs result.
+ Args:
+ param_dict:
+ it is in this format in config file:
+ "wifi_params":{
+ "Google.Wifi.SSID":{"string_value":"Home"},
+ "Google.Wifi.Home.SSID_2GHz":{"string_value":"Home"},
+ "Google.Wifi.Enable":{"boolean_value":"true"},
+ "Google.Wifi.BeaconType":{"string_value": "Basic"},
+ "Google.Wifi.BasicEncryptionModes":{"string_value":"WEPEncryption"}
+ Returns:
+ True: if set succeeded
+ False: otherwise
+ """
+ app_id = self.GetACSAppFromURL()
+ nbi_path = self.params['nbi_client_path']
+ account_id = self.params['account_id']
+ device_label = self.params['device_label']
+ parameter_value_struct = ''
+
+ # parameter_value_struct: <name: "Google.Wifi.BasicEncryptionModes"
+ # string_value: "WEPEncryption">
+ for key in param_dict.iterkeys():
+ name = key
+ param_type = param_dict[key].keys()[0]
+ value = None
+ if 'string' in param_type:
+ value = '"' + param_dict[key].values()[0] + '"'
+ else:
+ value = param_dict[key].values()[0]
+ parameter_value_struct += (
+ ' parameter_value_struct: <name: "'
+ + name + '" ' + param_type +': ' + value + '> ')
+
+ parameter_value_struct = None
+ cmd = (nbi_path
+ + ' --server /gns/project/apphosting/stubby/prod-appengine/'
+ '*/' + app_id + '/default/* --service AccountService '
+ '--method SetServiceConfigs --request \''
+ 'account_device_id: <account_id: "' + account_id
+ + '" device_label: "' + device_label + '"> parameter_list: < '
+ + parameter_value_struct + ' > async_apply_now: false\'')
+ print cmd
+ call_result = self.acs_instance.StubbyClientCall(cmd)
+ if 'FAILED' in call_result[0]:
+ info = self.log.CreateErrorInfo(
+ 'Warning', 'ACS failed on SetServiceConfigs query: ' + cmd)
+ self.log.SendLines(self.test_info, info)
+ return False
+ else:
+ print call_result
+ return call_result
+
+ def VerifyWiFiConfiguration(self):
+ """Test case: 14165034, WiFi configuration verification.
+
+ This test case will set WiFi parameters on ACS, and verify
+ that the service profile is correctly pushed to device.
+ Thin Bruno is configured with correct WiFi network.
+
+ The WiFi parameters and values in specified in config file
+ in JSON format, e.g.:
+ "Google.Wifi.SSID":{"string_value":"Home"},
+ "Google.Wifi.Home.SSID_2GHz":{"string_value":"Home"},
+ "Google.Wifi.Enable":{"boolean_value":"true"},
+ "Google.Wifi.BeaconType":{string_value: "Basic"},
+ "Google.Wifi.BasicEncryptionModes":{"string_value":"WEPEncryption"}
+
+ Returns:
+ return False if test failed
+ """
+ info = self.log.CreateProgressInfo(
+ '10%', 'Setup SetServiceConfigs on ACS...')
+ self.log.SendLine(self.test_info, info)
+ if not self.SetServiceConfigs(self.params['wifi_params']):
+ return False
+ else:
+ info = self.log.CreateProgressInfo(
+ '20%', 'Setup SetServiceConfigs on ACS succeed.')
+ self.log.SendLine(self.test_info, info)
+
+ # Verify if the service is pushed to device
+ # TODO(lmeng): what parameters to set and to verify
+
+ #################### for Data Model Test Case ####################
+
+ def Run(self):
+ """Run the test case."""
+ ####### Add your code here -- BEGIN #######
+ print 'Test Started...'
+ self.Init()
+ self.p_ssh.SshRetry(5, 15)
+ info = self.log.CreateProgressInfo(
+ '5%', 'SSH session to device successfully established!')
+ self.log.SendLine(self.test_info, info)
+
+ #check device profile/image is as erquired management url from ACS
+ self.TestEnvCheck()
+ info = self.log.CreateProgressInfo(
+ '10%', 'Check device test setup completed!')
+ self.log.SendLine(self.test_info, info)
+
+ if (self.test_info['testID'] == '14187024'
+ or self.test_info['testID'] == '14165033'
+ or self.test_info['testID'] == '14315008'
+ or self.test_info['testID'] == '14165035'
+ or self.test_info['testID'] == '14314007'
+ or self.test_info['testID'] == '11865133'
+ or self.test_info['testID'] == '14335001'
+ or self.test_info['testID'] == '14266498'
+ or self.test_info['testID'] == '14319149'
+ or self.test_info['testID'] == '14314008'):
+ self.VerifyAllReqParameters()
+ elif self.test_info['testID'] == '11722375':
+ self.VerifySetParameterValuesRPC()
+ elif self.test_info['testID'] == '14315009':
+ self.VerifyManagementServerURL()
+ elif self.test_info['testID'] == '14314009':
+ self.VerifyMonitorTemperature()
+ elif self.test_info['testID'] == '14165038':
+ self.VerifyAutoChannelEnable()
+ elif self.test_info['testID'] == '15643845':
+ self.VerifyNTPTimeZoneConfig()
+ elif self.test_info['testID'] == '14165034':
+ self.VerifyWiFiConfiguration()
+ else:
+ return
print 'Test Completed...'
####### Add your code here -- END #######
@@ -447,4 +1417,14 @@
self.p_ssh.Close()
if __name__ == '__main__':
- test = DataModelTest(testID='14187024', key_word='DataModel')
+ # Test cases defined in this file:
+ test_defined = ['14187024', '14165033', '14315008', '14165035', '14314007',
+ '11865133', '14335001', '14266498', '14319149', '14314008',
+ '11722375', '14315009', '14314009', '14165038', '15643845',
+ '14165034']
+ # To execute test cases that defined in config file:
+ test = DataModelTest(testID='14165034')
+ test_to_execute = testCase.TestCase.FindTestCaseToExecute('config.cfg')
+ for test_id in test_to_execute:
+ if test_id in test_defined:
+ test = DataModelTest(testID=test_id)
diff --git a/device.py b/device.py
index c02fa33..f3eb65c 100644
--- a/device.py
+++ b/device.py
@@ -1,17 +1,24 @@
#!/usr/bin/python
# Copyright 2012 Google Inc. All Rights Reserved.
-"""This class defines devices."""
+"""This class defines devices.
-__author__ = 'Lin Xue (linxue@google.com)'
-
-"""This file defines the base class of all devices,
+ This file defines the base class of all devices,
and specific device classes, such as Bruno, Spirent, etc.
"""
+__author__ = 'Lin Xue (linxue@google.com)'
+__author__ = 'Lehan Meng (lmeng@google.com)'
+
+
+import re
+
+import ip
+
class Device(object):
"""Base class of all devices.
+
information of device class:
addr: address of device
user: user name of device
@@ -23,24 +30,14 @@
other: other information of device
"""
- dev_info = {'addr': 'None',
- 'user': 'None',
- 'pwd': 'None',
- 'dev_name': 'None',
- 'cmd_prompt': 'None',
- 'other': 'None'}
-
def GetDevInfo(self):
"""This function returns device information."""
-
return (self.dev_info['dev_name'], self.dev_info['other'])
def SetLogging(self, logging):
- """This function set logging for device"""
-
+ """This function set logging for device."""
self.log = logging
return
-
# End of Device class
@@ -48,13 +45,20 @@
"""Bruno device class."""
def __init__(self, **kwargs):
- """ Constructor for Bruno device
- device name: Bruno, and other device informations
+ """Constructor for Bruno device.
+
+ device name: Bruno, and other device informations
"""
+ self.dev_info = {'addr': 'None',
+ 'user': 'None',
+ 'pwd': 'None',
+ 'dev_name': 'None',
+ 'cmd_prompt': 'None',
+ 'other': 'None'}
+
self.dev_info['dev_name'] = 'Bruno'
for s in kwargs:
- self.dev_info[s] = kwargs[s]
-
+ self.dev_info[s] = kwargs[s]
self.dev_ssh = None
# Bruno Device attributes
@@ -76,26 +80,26 @@
self.dev_epgpri = None
# EPG secondary
self.dev_epgsec = None
-
return
def GetDevCmd(self, cmd='', dev_attr='', dev_log=''):
"""This function sends command to Bruno.
+
Then it gets back the results
If success, save the results and write log
If fail, show Warning message
- Args:
- cmd:
- the command sent to Bruno system
- to query the device information
- dev_attr:
- the device attribute
- which can be get from this command
- dev_log:
- the logging message to be shown in log
-
+ Args:
+ cmd:
+ the command sent to Bruno system
+ to query the device information
+ dev_attr:
+ the device attribute
+ which can be get from this command
+ dev_log:
+ the logging message to be shown in log
+ Returns:
+ return the command results
"""
-
# Send command to query Bruno device information
self.dev_ssh.SendCmd(cmd)
@@ -111,8 +115,7 @@
'Get ' + dev_log + ': ' + line)
self.log.SendLine(None, info)
dev_attr = line
-
- return line
+ return line.strip()
def GetSerialNumber(self):
"""This function returns Bruno device serial number."""
@@ -130,20 +133,107 @@
return result
- def GetIPAddress(self):
- """This function returns Bruno device IP address."""
+ def VerifyCurrentVersion(self, version):
+ """Check if the current software version matches the given version.
+ Args:
+ version: the expected version string to check with device software
+ Returns:
+ True: if the current version matches the given version
+ False: if otherwise
+ """
+ if version == self.GetCurrentVersion():
+ return True
+ else:
+ return False
+
+ def GetIPaddress(self):
+ """This function returns Bruno device IP address."""
+ # Obsoleted
result = self.GetDevCmd(r'ifconfig br0', self.dev_ip,
'IP address')
return result
+ def GetDNSServer(self):
+ """This function returns device DNS server name."""
+ self.dev_ssh.SendCmd('cat /etc/resolv.conf')
+ cmd_list = self.dev_ssh.GetCmdOutput()
+ dns = None
+ for line in cmd_list:
+ m = re.search('nameserver (.*)', line)
+ if m:
+ dns = m.group(1)
+ break
+ return dns
+
+ def GetTimeServer(self):
+ """This function returns device DNS server name."""
+ self.dev_ssh.SendCmd('cat /etc/ntpd.conf')
+ cmd_list = self.dev_ssh.GetCmdOutput()
+ ts = None
+ for line in cmd_list:
+ m = re.search('server (.*)', line)
+ if m:
+ ts = m.group(1)
+ break
+ return ts
+
+ def GetGVSBHost(self):
+ """This function returns device GVSB host server name."""
+ self.dev_ssh.SendCmd('cat /tmp/gvsbhost')
+ cmd_line = self.dev_ssh.GetCmdOutput(2)[0]
+ m = re.search('http[s]?://[\w\d\./-]*', cmd_line)
+ if m:
+ return m.group(0)
+ return None
+
+ def GetIPv4Address(self):
+ """This function returns Bruno device IPv4 address."""
+ self.dev_ssh.SendCmd('ip addr show dev br0')
+ cmd_list = self.dev_ssh.GetCmdOutput()
+ address = None
+ for line in cmd_list:
+ if 'inet ' in line and 'scope global' in line:
+ address = ip.IPADDR(line).IsLikeIpv4Address()
+
+ if not address:
+ info = self.log.CreateErrorInfo('critical',
+ 'Can not detect IPv4 address on device!')
+ self.log.SendLine(None, info)
+ return address
+
+ def GetIPv6Address(self):
+ """This function returns Bruno device IPv6 address.
+
+ This function will return a list of addresses. Sometimes device may
+ have multiple IPv6 addresses.
+
+ Returns:
+ return the obtained IPv6 address
+ """
+ self.dev_ssh.SendCmd('ip addr show dev br0')
+ cmd_list = self.dev_ssh.GetCmdOutput()
+ address = []
+ for line in cmd_list:
+ if 'inet6 ' in line and 'scope global' in line:
+ print line
+ m = re.match('inet6 ([\da-f:]+)/\d+ scope global \w*', line.strip())
+ if not m:
+ info = self.log.CreateErrorInfo(
+ 'critical', 'Can not detect valid IPv6 address '
+ 'on device! ' + line)
+ self.log.SendLine(None, info)
+ return address
+ addr = m.group(1)
+ address.append(addr)
+ return address
+
def GetDevTime(self):
"""This function returns Bruno device current date."""
result = self.GetDevCmd(r'date', self.dev_time,
'current date')
-
return result
def GetACSUrl(self):
@@ -151,9 +241,22 @@
result = self.GetDevCmd(r'cat /tmp/cwmp/acs_url', self.dev_acs,
'ACS URL')
-
return result
+ def VerifyCurrentACSURL(self, url):
+ """Check if the current ACS URL matches the given URL.
+
+ Args:
+ url: the expected url string to check with device ACS URL
+ Returns:
+ True: if the current url matches the given url
+ False: otherwise
+ """
+ if url == self.GetACSUrl():
+ return True
+ else:
+ return False
+
def GetDnldImage(self):
"""This function returns Bruno device current downloading image."""
@@ -163,7 +266,7 @@
return result
def GetProductClass(self):
- """This function returns Bruno device product class"""
+ """This function returns Bruno device product class."""
result = self.GetDevCmd(r'cat /etc/platform', self.dev_class,
'product class')
@@ -171,7 +274,7 @@
return result
def GetEpgPrimary(self):
- """This function returns Bruno device primary EPG"""
+ """This function returns Bruno device primary EPG."""
result = self.GetDevCmd(r'cat /tmp/epgprimary', self.dev_epgpri,
'EPG primary')
@@ -179,7 +282,7 @@
return result
def GetEpgSecond(self):
- """This function returns Bruno device secondary EPG"""
+ """This function returns Bruno device secondary EPG."""
result = self.GetDevCmd(r'cat /tmp/epgsecondary', self.dev_epgsec,
'EPG secondary')
@@ -197,7 +300,7 @@
# Other device informations
self.GetSerialNumber()
self.GetCurrentVersion()
- self.GetIPAddress()
+ self.GetIPv4Address()
self.GetDevTime()
self.GetACSUrl()
self.GetDnldImage()
@@ -207,6 +310,59 @@
return
+ def GetTimeStamp(self, line=None):
+ """Extract the time information of most current event from Device log.
+
+ i.e., the time that the last event happens since reboot (in seconds)
+ Args:
+ line: a line of device log which contains event time information.
+ If it has value of 'None', then retrieve the last a few lines from
+ device log to extract time information.
+ Returns:
+ return the time stamp string if succeed, return -1 otherwise.
+ """
+ if not line:
+ # get time stamp from Device log file
+ self.dev_ssh.SendCmd('dmesg | grep cwmpd:')
+ log_list = self.dev_ssh.GetCmdOutput()
+
+ for line in log_list:
+ m = re.match('\\[[\s]*(\d*\\.\d{3})\\]', line)
+ if m:
+ # Match, return the time stamp
+ return m.group(1)
+ else:
+ # get time stamp from a Device log line
+ m = re.match('\\[[\s]*(\d*\\.\d{3})\\]', line)
+ if m:
+ # Match, return the time stamp
+ return m.group(1)
+ # No time stamp found
+ return -1
+
+ def FindLineInLog(self, log_list, time_stamp, pattern_line):
+ """Match a particular string from device logs.
+
+ Find a particular string or line from device log
+ Args:
+ log_list: the device log to search from
+ time_stamp: to search events that are after this time
+ pattern_line: the string or line that need to be matched in device log
+ Returns:
+ True: if 'line' matched
+ False: 'line' not found in device log
+ """
+ m = re.compile(pattern_line)
+ for line in log_list:
+ if float(self.GetTimeStamp(line)) > float(time_stamp):
+ #Debug
+ if 'detected' in line:
+ print 'here'
+
+ matching = m.search(line)
+ if matching:
+ return True
+ return False
# End of Bruno device class
@@ -214,7 +370,8 @@
"""Spirent device class."""
def __init__(self, **kwargs):
- """ Constructor for Spirent device
+ """Constructor for Spirent device.
+
device name: Spirent, and other device informations
"""
diff --git a/download.py b/download.py
index 2bfdc7f..d39b6e4 100755
--- a/download.py
+++ b/download.py
@@ -4,18 +4,11 @@
"""This class defines the test case "image download" from ACS.
This class extends the TestCase Class.
-testID: 11843140
-This test does the following tasks:
- - check current image version
- - if the current version is the same as expected version,
- this test will first to try to downgrade it to the downgrade_version.
- - Then, it will Run image download test
- - Fianlly, it will downgrade to downgrade_version if this has not been
- done. This is to test the download handling capabilities of the
- expected_version
- - configure ACS instance with these software versions
- - verify image download and installation to be complete and successful, by
- observing a successfully reboot after installation
+This file includes the following test cases:
+ - testID: 11843140 7.6.11 Verify firmware upgrade/downgrade by ACS
+ - testID: 14165036 7.6.18 Negative test: Bruno Image download interruption
+ - testID: 14334001 7.6.25.3 File Transfer (File upload is optional, this is
+ then basically the same test case as download.)
"""
__author__ = 'Lehan Meng (lmeng@google.com)'
@@ -48,15 +41,12 @@
def Init(self):
"""Initialte the DownloadTest instance."""
- self.p_ssh = ssh.SSH(user=self.params['user'],
- addr=self.params['addr'],
- pwd=self.params['pwd'],
- bruno_prompt=self.params['bruno_prompt'],
- addr_ipv6=self.params['addr_ipv6'],
- athena_user=self.params['athena_user'],
- athena_pwd=self.params['athena_pwd'],
- jump_server=self.params['jump_server'])
- self.p_ssh.Setlogging(self.log)
+ if not self.p_ssh:
+ self.p_ssh = ssh.SSH(user=self.params['user'],
+ addr=self.params['addr'],
+ bruno_prompt=self.params['bruno_prompt'],
+ addr_ipv6=self.params['addr_ipv6'])
+ self.p_ssh.SetLogging(self.log)
self.__debug = False
self.__short_delay = 5 #short delay: 5 seconds
self.__delay = 180 #medium delay: 180 seconds
@@ -130,9 +120,13 @@
return m.group(1)
# No time stamp found
- return -1
+ info = self.log.createErrorInfo(
+ 'Critical', 'Exit! Can not find time information from '
+ 'device log ...')
+ self.log.sendLine(self.test_info, info)
+ return os.sys.exit(1)
- def ConfigACS(self, version_id=None):
+ def ConfigACS(self, version_id):
"""Setup the ACS device profile with expected image.
Then restart the cwmpd process on device to
@@ -143,19 +137,12 @@
return the time stamp string if succeed, return -1 otherwise.
"""
#configure ACS:
- acs_instance = acs.ACS(version_id)
+ acs_instance = acs.ACS(acs_path=self.params['acs_path'])
acs_instance.SetLogging(self.log)
- acs_instance.SaveConfiguration()
+ acs_instance.SaveConfiguration(
+ self.params['profile_id'], version_id, self.params['acs_app_id'],
+ self.params['acs_host_name'])
- #self.p_ssh.SendCmd('/etc/Init.d/S85catawampus restart')
- # To setup any device service parameter using nbi_client will trigger
- # ACS to make a remote connection request to the device.
- # However, currently ACS does not provide separate stubby call to
- # only request a remote connection.
- # As walk around:
- # 1. call remote management URL locally to initiate Inform immediately
- # 2. wait for the next periodic inform to initiate download
- # Here go for the 2nd option.
time_stamp = self.GetTimeStamp()
return time_stamp
@@ -223,29 +210,32 @@
"""
time.sleep(5)
s = self.GetTimeStamp()
+ print 'previous time stamp: ' + time_stamp
+ print 'current time stamp: ' + s
if float(s) < float(time_stamp) and s is not -1:
return True
return False
- def CheckImageInstallation(self, time_stamp):
+ def CheckImageInstallation(self, time_stamp, version):
"""Check if the Image installation and Device reboot is successful.
An upgrade is considered complete only after the device is rebooted
after image installation
Args:
time_stamp: check if a reboot is done after this time
+ version: the image version that needs to be installed
Returns:
return True if installation succeeded
return False otherwise
"""
- self.p_ssh.ExitToAthena()
- time.sleep(3*self.__short_delay)
- self.p_ssh.SshRetryFromAthena(set_key=False)
+ self.p_ssh.Close()
+ time.sleep(6*self.__short_delay)
+ self.p_ssh.SshRetry()
count = 0
ts = time_stamp
while not self.IsRebooted(ts):
count +=1
- if count*self.__short_delay*3 > self.__long_delay:
+ if count*self.__short_delay*6 > self.__long_delay:
info = self.log.CreateErrorInfo(
'critical',
'Error! File download longer than ' + str(self.__long_delay)
@@ -256,56 +246,50 @@
t = self.GetTimeStamp()
if float(t) > float(ts):
ts = t
- self.p_ssh.ExitToAthena()
+ self.p_ssh.Close()
info = self.log.CreateProgressInfo(
- '90%', 'Wait ' + str(3*self.__short_delay)
+ '---', 'Wait ' + str(6*self.__short_delay)
+ ' seconds for image installation and device reboot...')
self.log.SendLine(self.test_info, info)
- time.sleep(3*self.__short_delay)
- self.p_ssh.SshRetryFromAthena(set_key=False)
+ time.sleep(6*self.__short_delay)
+ self.p_ssh.SshRetry()
time.sleep(2*self.__short_delay)
self.p_ssh.SendCmd('more /etc/version')
line = self.p_ssh.GetCmdOutput()[1]
crt_version = line.strip()
- print crt_version + '########' + self.params['expected_version']
- if crt_version == self.params['expected_version']:
+ print crt_version + '########' + version
+ if crt_version == version:
return True
else:
return False
- def Run(self):
- """Run the test case."""
- ####### Add your code here -- BEGIN #######
- print 'Test Started...'
- self.Init()
- self.p_ssh.SshToAthena()
- info = self.log.CreateProgressInfo(
- '5%', 'SSH session to Athena server successfully established!')
- self.log.SendLine(self.test_info, info)
+ def VerifyImageDownload(self):
+ """Verify image download and upgrade.
+ This test checks the following:
+ - check current image version
+ - if current_version is not expected_version as defined in config file:
+ - Upgrade to expected_version (verify expected version can boot up)
+ - Downgrade from expected_version to downgrade_version
+ (verify downgrade handling capability of expected_version image)
+ - Finally upgrade to expected_version, and keep device in this state.
+ - if the current version is already the expected_version,
+ - Downgrade from expected_version to downgrade_version
+ (verify downgrade handling capability of expected_version image)
+ - Finally upgrade to expected_version, and keep device in this state.
+
+ At the same time, it also verifies:
+ - configure ACS with these software versions
+ """
max_test_idx = 3
current_test_idx = 1
upgrade = True
- while current_test_idx < max_test_idx:
- self.p_ssh.SshRetryFromAthena(set_key=True)
+ while current_test_idx <= max_test_idx:
info = self.log.CreateResultInfo(
'---', 'Test Sequence Number: ' + str(current_test_idx))
self.log.SendLine(self.test_info, info)
- while self.CheckDownloadFileExists():
- # current in download
- info = self.log.CreateProgressInfo(
- '10%', 'Another downloading in progress, retry after '
- + str(self.__short_delay) + 'seconds...')
- self.log.SendLine(self.test_info, info)
- self.p_ssh.ExitToAthena()
- time.sleep(self.__short_delay)
- self.p_ssh.SshRetryFromAthena(set_key=False)
-
- info = self.log.CreateProgressInfo(
- '15%', 'SSH session to device successfully established!')
- self.log.SendLine(self.test_info, info)
self.CheckACSUrl()
info = self.log.CreateProgressInfo('20%', 'Current ACS url: '
@@ -317,45 +301,199 @@
+ self.params['current_version'])
self.log.SendLine(self.test_info, info)
- if upgrade == True:
+ if self.params['current_version'] == self.params['expected_version']:
+ if current_test_idx == 1:
+ current_test_idx += 1
+ upgrade = False
+ continue
+
+ version = None
+ if upgrade:
self.time_stamp = self.ConfigACS(self.params['expected_version_id'])
info = self.log.CreateProgressInfo('40%', 'Expected Version: '
+ self.params['expected_version'])
self.log.SendLine(self.test_info, info)
+ version = self.params['expected_version']
else:
self.time_stamp = self.ConfigACS(self.params['downgrade_version_id'])
- self.params['expected_version'] = self.params['downgrade_version']
- self.params['expected_version_id'] = self.params['downgrade_version_id']
info = self.log.CreateProgressInfo('40%', 'Downgrade Version: '
+ self.params['downgrade_version'])
self.log.SendLine(self.test_info, info)
+ version = self.params['downgrade_version']
info = self.log.CreateProgressInfo(
- '40%', 'Successfully configured ACS for image version')
+ '50%', 'Successfully configured ACS for image version: ' + version)
self.log.SendLine(self.test_info, info)
time.sleep(self.__short_delay) # time delay for log update
self.time_stamp = self.GetTimeStamp()
- if self.CheckImageInstallation(self.time_stamp):
+ if self.CheckImageInstallation(self.time_stamp, version):
info = self.log.CreateProgressInfo(
'100%', 'Image successfully upgraded to expected version: '
'from: ' + self.params['current_version']
- + ' to: ' + self.params['expected_version'])
+ + ' to: ' + version)
self.log.SendLine(self.test_info, info)
info = self.log.CreateResultInfo(
'Pass', 'Image successfully upgraded to expected version: '
'from: ' + self.params['current_version']
- + ' to: ' + self.params['expected_version'])
+ + ' to: ' + version)
self.log.SendLine(self.test_info, info)
else:
info = self.log.CreateErrorInfo(
'critical',
'Error! Image version does not match expected version!')
self.log.SendLine(self.test_info, info)
+ info = self.log.CreateResultInfo(
+ 'Failed', 'Image failed to upgraded to expected version: '
+ 'from: ' + self.params['current_version']
+ + ' to: ' + version)
+ self.log.SendLine(self.test_info, info)
current_test_idx += 1
- self.p_ssh.ExitToAthena()
- upgrade = False
+ if upgrade:
+ upgrade = False
+ else:
+ upgrade = True
+
+ def ImageUpgrade(self, expected_version, expected_version_id):
+ """This function upgrade device image to expected version.
+
+ Args:
+ expected_version: the version to be upgraded to
+ expected_version_id: the id of the expected version
+ Returns:
+ True if upgrade succeeds
+ False if upgrade fails
+ """
+ version = self.GetVersion()
+ if version == expected_version:
+ info = self.log.CreateProgressInfo(
+ '---', 'Image is already expected versioin: '
+ + expected_version)
+ self.log.SendLine(self.test_info, info)
+ return True
+ self.time_stamp = self.ConfigACS(expected_version_id)
+ info = self.log.CreateProgressInfo(
+ '---', 'Successfully configured ACS for image version: '
+ + expected_version)
+ self.log.SendLine(self.test_info, info)
+
+ time.sleep(self.__short_delay) # time delay for log update
+ self.time_stamp = self.GetTimeStamp()
+ if self.CheckImageInstallation(self.time_stamp, expected_version):
+ info = self.log.CreateProgressInfo(
+ '---', 'Image successfully upgraded to expected version: '
+ 'from: ' + version + ' to: ' + expected_version)
+ self.log.SendLine(self.test_info, info)
+ return True
+ else:
+ info = self.log.CreateErrorInfo(
+ 'critical',
+ 'Error! Image version does not match expected version!')
+ self.log.SendLine(self.test_info, info)
+ return False
+
+ def VerifyDownloadInterrupt(self):
+ """Negative test case: verify image download interruption.
+
+ This case tests device's capability of image upgrade in case of
+ power loss, power cycle, or multiple download requests from ACS.
+ The device should finally be able to complete the download and
+ image upgrade process from expected_version to downgrade_version.
+
+ Returns:
+ return: False if the verification fails
+ return: True otherwise
+ """
+ self.CheckVersion()
+ if self.params['current_version'] != self.params['expected_version']:
+ info = self.log.CreateProgressInfo(
+ '5%', 'Current version is not expected version to test, upgrade to: '
+ + self.params['expected_version'])
+ self.log.SendLine(self.test_info, info)
+ if not self.ImageUpgrade(self.params['expected_version'],
+ self.params['expected_version_id']):
+ info = self.log.CreateErrorInfo(
+ 'critical',
+ 'Failed to upgrade version to: '
+ + self.params['expected_version'])
+ self.log.SendLine(self.test_info, info)
+ return False
+ self.ConfigACS(self.params['downgrade_version_id'])
+ info = self.log.CreateProgressInfo(
+ '10%', 'Successfully configured ACS for image version: '
+ + self.params['downgrade_version'])
+ self.log.SendLine(self.test_info, info)
+
+ time.sleep(6*self.__short_delay)
+
+ info = self.log.CreateProgressInfo(
+ '40%', 'Download started, reboot the device.')
+ self.log.SendLine(self.test_info, info)
+ time_stamp = self.GetTimeStamp()
+ self.p_ssh.SendCmd('reboot')
+ self.p_ssh.GetCmdOutput()
+ while not self.IsRebooted(time_stamp):
+ self.p_ssh.Close()
+ time.sleep(self.__short_delay*3)
+ self.p_ssh.SshRetry()
+ info = self.log.CreateProgressInfo(
+ '60%', 'Downloading interrupted, waiting for device boot up.')
+ self.log.SendLine(self.test_info, info)
+
+ time_stamp = self.GetTimeStamp()
+ version = self.GetVersion()
+ if version != self.params['downgrade_version']:
+ count = 0
+ while not self.IsRebooted(time_stamp):
+ count += 1
+ if count*self.__short_delay > self.__long_delay:
+ info = self.log.CreateErrorInfo(
+ 'critical',
+ 'Error! Image downloading is not successful after interruption!')
+ self.log.SendLine(self.test_info, info)
+ info = self.log.CreateResultInfo(
+ 'Failed',
+ 'Image failed to upgraded to version: '
+ + self.params['downgrade_version'] + ' ('
+ + self.__long_delay + ' seconds) after interrupted.')
+ self.log.SendLine(self.test_info, info)
+ return False
+ time_stamp = self.GetTimeStamp()
+ info = self.log.CreateProgressInfo(
+ '80%', 'Waiting for downloading complete after interruption.')
+ self.log.SendLine(self.test_info, info)
+ time.sleep(self.__short_delay*5)
+
+ info = self.log.CreateProgressInfo(
+ '100%', 'Image successfully upgraded to version: '
+ + self.params['downgrade_version'] + ' after interrupted.')
+ self.log.SendLine(self.test_info, info)
+ info = self.log.CreateResultInfo(
+ 'Pass', 'Image successfully upgraded to version: '
+ + self.params['downgrade_version'] + ' after interrupted.')
+ self.log.SendLine(self.test_info, info)
+ return True
+
+ def Run(self):
+ """Run the test case."""
+ ####### Add your code here -- BEGIN #######
+ print 'Test Started...'
+ self.Init()
+ self.p_ssh.SshRetry()
+ info = self.log.CreateProgressInfo(
+ '5%', 'SSH session to device successfully established!')
+ self.log.SendLine(self.test_info, info)
+
+ if self.test_info['testID'] == '11843140':
+ self.VerifyImageDownload()
+ info = self.log.CreateResultInfo(
+ '----', 'For file transfer test, refer to image download test result:'
+ ' testID: 11843140.')
+ self.log.SendLine(self.test_info, info)
+ elif self.test_info['testID'] == '14165036':
+ self.VerifyDownloadInterrupt()
+
print 'Test Completed...'
####### Add your code here -- END #######
@@ -366,4 +504,10 @@
if __name__ == '__main__':
- DownloadTest(testID='11843140', key_word='Download')
+ # Test cases defined in this file:
+ test_defined = ['11843140', '14165036', '14334001']
+ # To execute test cases that defined in config file:
+ test_to_execute = testCase.TestCase.FindTestCaseToExecute('config.cfg')
+ for test_id in test_to_execute:
+ if test_id in test_defined:
+ test = DownloadTest(testID=test_id)
diff --git a/logging.py b/logging.py
index da14edb..dd1654a 100755
--- a/logging.py
+++ b/logging.py
@@ -16,17 +16,13 @@
import datetime
+import errno
+import os
class Logging(object):
"""This Class collects and writes test information to log files."""
- params = {'std_out': '1',
- 'f_result': 'result.log',
- 'f_error': 'error.log',
- 'f_progress': 'progress.log',
- 'delimiter': '\t'}
-
def __init__(self, **kwargs):
"""initiate the logging instance.
@@ -36,15 +32,129 @@
kwargs['f_progres']: file name for test progres
kwargs['std_out']: by default, send a copy of the log info to stdout
"""
- for s in ('f_result', 'f_error', 'f_progress', 'std_out'):
- if s in kwargs:
- self.params[s] = kwargs[s]
- self.rst_file = open(self.params['f_result'], 'w')
- self.err_file = open(self.params['f_error'], 'w')
- self.prg_file = open(self.params['f_progress'], 'w')
+ self.params = {'std_out': '1',
+ 'f_result': 'result.log',
+ 'f_error': 'error.log',
+ 'f_progress': 'progress.log',
+ 'delimiter': '\t',
+ 'out_folder': 'log',
+ 'in_folder': 'data'}
+ for s in kwargs:
+ self.params[s] = kwargs[s]
+
+ try:
+ os.makedirs(self.params['out_folder'])
+ except OSError, e:
+ if e.errno != errno.EEXIST:
+ raise
+
+ now = datetime.datetime.now()
+ s_time = now.strftime('%Y-%m-%d_%H:%M:%S.%f')
+ for f_name in ['f_result', 'f_error', 'f_progress']:
+ name = self.ParseLogFileName(self.params[f_name], 'w', s_time)
+ if name:
+ self.params[f_name] = name
+ else:
+ print 'Error! Fail to create log File.'
+ self.rst_file = open(self.params['f_result'], 'w+')
+ self.err_file = open(self.params['f_error'], 'w+')
+ self.prg_file = open(self.params['f_progress'], 'w+')
self.NewTestStart()
+ def CreateFile(self, f_name, access='r'):
+ """Create a file for read/write.
+
+ Args:
+ f_name: the file name that needs to be created
+ access: 'r': read, input file
+ 'w': write, output file
+ 'rw': read and write
+ Returns:
+ f_obj: return the file object
+ if not succeed, return False
+ """
+ f_obj = None
+ if access == 'r':
+ # for input file
+ try:
+ f_obj = open(f_name, 'r')
+ except IOError:
+ print 'Cannot open the input file, return'
+ return False
+ elif access == 'w':
+ # for input file
+ try:
+ os.makedirs(self.params['out_folder'])
+ except OSError, e:
+ if e.errno != errno.EEXIST:
+ print 'Cannot create folder! Return'
+ return False
+ full_path = self.ParseLogFileName(f_name, access)
+ if full_path:
+ try:
+ f_obj = open(full_path, 'w+')
+ except IOError:
+ print 'Cannot open the given file, return'
+ return False
+ else:
+ # Can not parse file name
+ print 'Cannot parse given file name'
+ return False
+ else:
+ # read-write file:
+ try:
+ f_obj = open(f_name, 'r')
+ except IOError:
+ print 'Cannot open the input file, return'
+ return False
+ return f_obj
+
+ def ParseLogFileName(self, f_name, access='r', time_stamp=None):
+ """Generate an uniq log file name for each test case instance.
+
+ Args:
+ f_name: file name
+ access: 'r': read mode
+ 'w': write mode
+ 'rw': read-write
+ time_stamp: the time tag used for file name
+ if None, create a new tag using current time
+ Returns:
+ return the parsed file name
+ """
+ if not f_name:
+ f_name = 'logFile.log'
+ if not time_stamp:
+ now = datetime.datetime.now()
+ s_time = now.strftime('%Y-%m-%d_%H:%M:%S.%f')
+ else:
+ s_time = time_stamp
+
+ ls = f_name.split('.')
+ ext_name = ''
+ name = ''
+ if len(ls) == 1:
+ name = ls[0]
+ else:
+ ext_name = ls.pop(-1)
+ for s in ls:
+ name += (s+'.')
+ name = name.rstrip('.')
+
+ if not ext_name:
+ ext_name = 'log'
+ folder = None
+ if access == 'r':
+ folder = self.params['in_folder']
+ elif access == 'w':
+ folder = self.params['out_folder']
+ else:
+ folder = self.params['in_folder']
+ name = (folder + '/' + name + '_testID-' + self.params['testID']
+ + '_'+ s_time + '.' + ext_name)
+ return name
+
def SendLineToResult(self, test_info, result_info):
"""Send test result (one-line) information to the result file.
@@ -56,7 +166,7 @@
"""
now = datetime.datetime.now()
if test_info is not None:
- line = (now.strftime('%Y-%m-%d %H:%M') + self.params['delimiter']
+ line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
+ 'testID:' + test_info['testID']
+ self.params['delimiter'] + 'TestStartAt:'
+ test_info['start_time']
@@ -69,7 +179,8 @@
if self.params['std_out'] > 0:
print line
- return self.rst_file.write(line)
+ self.rst_file.write(line)
+ self.rst_file.flush()
def NewTestStart(self):
"""Mark the start of a new test in the file."""
@@ -91,7 +202,7 @@
"""
now = datetime.datetime.now()
if test_info is not None:
- line = (now.strftime('%Y-%m-%d %H:%M') + self.params['delimiter']
+ line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
+ 'testID:' + test_info['testID'] + self.params['delimiter']
+ 'TestStartAt:' + test_info['start_time']
+ self.params['delimiter'] + 'Keyword:'
@@ -99,13 +210,14 @@
+ error_info['severity'] + self.params['delimiter']
+ error_info['note'] + '\n')
else:
- line = (now.strftime('%Y-%m-%d %H:%M') + self.params['delimiter'] +
+ line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter'] +
error_info['severity'] + self.params['delimiter']
+ error_info['note'] + '\n')
if self.params['std_out'] > 0:
print line
- return self.err_file.write(line)
+ self.err_file.write(line)
+ self.err_file.flush()
def SendLineToProgress(self, test_info, progress_info):
"""Send test progress (one-line) information to the progress file.
@@ -119,20 +231,21 @@
"""
now = datetime.datetime.now()
if test_info is not None:
- line = (now.strftime('%Y-%m-%d %H:%M') + self.params['delimiter']
+ line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
+ 'testID:' + test_info['testID'] + self.params['delimiter']
+ 'TestStartAt:'+ test_info['start_time']
+ self.params['delimiter'] + 'Keyword:' + test_info['key_word']
+ self.params['delimiter'] + progress_info['percent']
+ self.params['delimiter'] + progress_info['note'] + '\n')
else:
- line = (now.strftime('%Y-%m-%d %H:%M') + self.params['delimiter']
+ line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
+ progress_info['percent'] + self.params['delimiter']
+ progress_info['note'] + '\n')
if self.params['std_out'] > 0:
print line
- return self.prg_file.write(line)
+ self.prg_file.write(line)
+ self.prg_file.flush()
def SendLine(self, test_info, info):
"""Send test (one-line) information to the corresponding log file.
@@ -162,7 +275,7 @@
Args:
test_info: test case related info: testID, start_time, key_word, etc
- info: test results/error/progress information (single line)
+ info: test results/error/progress information
test_info could be "None" for class other than TestCase
Returns:
return 1 when succeed
diff --git a/ssh.py b/ssh.py
index e721058..7232542 100755
--- a/ssh.py
+++ b/ssh.py
@@ -54,9 +54,10 @@
'bruno_prompt': '\(none\)#',
'jump_server': 'jmp.googlefiber.net',
'jump_prompt': None,
- 'athena_user': None,
- 'athena_pwd': None,
- 'athena_prompt': None}
+ 'athena_user': 'lmeng',
+ 'athena_pwd': 'changeme',
+ 'athena_prompt': None,
+ 'ssh_use_athena': False}
self.tmp_file = tempfile.TemporaryFile(mode='w+t')
@@ -66,19 +67,13 @@
for s in kwargs:
self.params[s] = kwargs[s]
-
#populate prompt on jump and athena server:
- if self.params['athena_user'] is not 'None':
+ if self.params['athena_user']:
self.params['jump_prompt'] = self.params['athena_user'] + '@jmp101.nuq1:'
self.params['athena_prompt'] = ('[' + self.params['athena_user']
+ '@athenasrv3 ~]$')
- if dev is not None:
- # parameters used to open an ssh tunnel to this device
- for s in ('user', 'addr', 'pwd', 'bruno_prompt', 'addr_ipv6'):
- self.params[s] = kwargs[s]
-
- def Setlogging(self, logging):
+ def SetLogging(self, logging):
"""Setup the logging file(s)."""
self.log = logging
@@ -102,7 +97,7 @@
p_ssh = pexpect.spawn('ssh '+self.params['user']+'@'+addr)
i = p_ssh.expect(
[ssh_newkey, 'password:', self.params['bruno_prompt'], pexpect.EOF,
- '\(none\)#', 'gfibertv#', pexpect.TIMEOUT], 20)
+ '\(none\)#', 'gfibertv#', pexpect.TIMEOUT], self.__long_delay)
while 1:
if i == 0:
@@ -123,7 +118,7 @@
if i == 5: self.params['bruno_prompt'] = 'gfibertv#'
return True
if i == 3 or i == 6:
- print 'Key or connection timeout'
+ print 'ssh did not respond, or connection timeout'
return False
if i < 0 or i > 6:
print 'Error, quit'
@@ -210,6 +205,7 @@
Returns:
return True upon success
"""
+ self.params['ssh_use_athena'] = True
p_ssh = pexpect.spawn('ssh -a ' + self.params['jump_server'])
print 'ssh -a jmp.googlefiber.net ...'
#p_ssh.expect('lmeng@jmp101.nuq1:.*[\\$]')
@@ -294,7 +290,7 @@
+ str(delay) + ' seconds')
self.log.SendLine(None, info)
time.sleep(delay)
- tunnel = self.SshFromAthena(set_key)
+ tunnel = self.SshFromAthena()
retry += 1
if retry >= max_retry:
@@ -309,11 +305,19 @@
'---', 'ssh session to Device successfully established!')
self.log.SendLine(None, info)
- def SendCmd(self, cmd):
- """Send a command to the Device over ssh tunnel."""
+ def SendCmd(self, cmd, delay=10):
+ """Send a command to the Device over ssh tunnel.
+
+ Args:
+ cmd: the shell command to execute
+ delay: time delay while waiting for shell prompt after command is
+ executed
+ Returns:
+ return True if send command succeeded
+ """
self.p_ssh.sendline(cmd)
i = self.p_ssh.expect(
- [self.params['bruno_prompt'], pexpect.EOF, pexpect.TIMEOUT], 10)
+ [self.params['bruno_prompt'], pexpect.EOF, pexpect.TIMEOUT], delay)
while 1:
if i == 0:
@@ -323,13 +327,16 @@
# prompt not returned
info = self.log.CreateErrorInfo(
'Warning', 'Device not responding to shell command or timeout.'
- ' Connect after 3 seconds ...')
+ ' Connect after 10 seconds ...')
self.log.SendLine(None, info)
- time.sleep(3)
- self.SshRetryFromAthena()
+ time.sleep(10)
+ if self.params['ssh_use_athena']:
+ self.SshRetryFromAthena()
+ else:
+ self.SshRetry()
self.p_ssh.sendline(cmd)
i = self.p_ssh.expect(
- [self.params['bruno_prompt'], pexpect.EOF, pexpect.TIMEOUT], 5)
+ [self.params['bruno_prompt'], pexpect.EOF, pexpect.TIMEOUT], delay)
def GetCmdOutput(self, buff_size=0):
"""Get lines from the command output of the device, in a bottom up manner.
@@ -375,18 +382,18 @@
def Close(self):
# exit the ssh tunnel
self.p_ssh.sendline('exit')
- i = self.expect([self.p_ssh.params['athena_prompt'],
- self.p_ssh.params['jump_prompt'],
- self.p_ssh.params['bruno_prompt'],
- pexpect.EOF, pexpect.TIMEOUT])
+ i = self.p_ssh.expect([self.params['athena_prompt'],
+ self.params['jump_prompt'],
+ self.params['bruno_prompt'],
+ pexpect.EOF, pexpect.TIMEOUT])
while 1:
if i == 0:
# now at athena server:
self.p_ssh.sendline('exit')
- i = self.expect([self.p_ssh.params['athena_prompt'],
- self.p_ssh.params['jump_prompt'],
- self.p_ssh.params['bruno_prompt'],
- pexpect.EOF, pexpect.TIMEOUT])
+ i = self.p_ssh.expect([self.params['athena_prompt'],
+ self.params['jump_prompt'],
+ self.params['bruno_prompt'],
+ pexpect.EOF, pexpect.TIMEOUT])
elif i == 1:
# now at jump server:
self.p_ssh.sendline('exit')
@@ -394,16 +401,15 @@
elif i == 2:
# now at bruno:
self.p_ssh.sendline('exit')
- i = self.expect([self.p_ssh.params['athena_prompt'],
- self.p_ssh.params['jump_prompt'],
- self.p_ssh.params['bruno_prompt'],
+ i = self.expect([self.params['athena_prompt'],
+ self.params['jump_prompt'],
+ self.params['bruno_prompt'],
pexpect.EOF, pexpect.TIMEOUT])
elif i == 3 or i == 4:
# time out:
- print 'Timeout when closing the ssh tunnel!'
+ print 'Exit from Device.'
break
else:
- print 'Error'
break
def __del__(self):
diff --git a/testCase.py b/testCase.py
index 2fee061..bd2932e 100755
--- a/testCase.py
+++ b/testCase.py
@@ -11,8 +11,11 @@
__author__ = 'Lehan Meng (lmeng@google.com)'
import datetime
+import json
import logging
+import os
import re
+
import device
@@ -29,12 +32,13 @@
placed in here.
"""
- def __init__(self, **kwargs):
+ def __init__(self, ssh=None, **kwargs):
"""Initiate a test class instance.
Args:
+ ssh: ssh tunnel to device
kwargs['testID']: The assigned test ID on TCM
- kwargs['title']: Title (section number) of the test case
+ kwargs['title']: Title (keyword) of the test case
kwargs['start_time']: Start time of the test case (for statistic purpose)
kwargs['key_word']: the label of the test case
kwargs['description']: description if required
@@ -49,17 +53,165 @@
'configFile': 'config.cfg'}
self.params = {}
- for s in ('testID', 'title', 'start_time', 'key_word',
- 'description', 'configFile'):
- if s in kwargs:
- self.test_info[s] = kwargs[s]
+ for s in kwargs:
+ self.test_info[s] = kwargs[s]
self.device = device.Device()
- self.log = logging.Logging()
- self.ParseConfig()
+ self.log = logging.Logging(testID=self.test_info['testID'])
+ self.ParseJSONConfigFile()
+ #self.ParseConfig()
+ if ssh:
+ self.p_ssh = ssh
+ else:
+ self.p_ssh = None
self.Run()
+ @staticmethod
+ def FindTestCaseID(file_name):
+ """Parse the configuration file for test case.
+
+ Find test ids in the configuration file.
+ Args:
+ file_name: the configure file to parse
+ Returns:
+ return the test case ids that needs to run the test
+ """
+ test_id_list = []
+ cfg_file = open(file_name, 'r')
+ cfg_list = cfg_file.readlines()
+ for line in cfg_list:
+ s = line.strip().strip('\n')
+ m = re.match(r'testID\s*:\s*(\d*)\s*$', s)
+ if (m is not None) and not s.startswith('#'):
+ test_id_list.append(m.group(1))
+ cfg_file.close()
+ return test_id_list
+
+ @staticmethod
+ def FindTestCaseToExecute(file_name):
+ """Parse the configuration file for test case.
+
+ Find test ids in the configuration file.
+ Args:
+ file_name: the configure file to parse
+ Returns:
+ return the test case ids that needs to run the test
+ """
+ test_id_list = []
+ try:
+ cfg_file = open(file_name, 'r')
+ except IOError:
+ print 'Cannot open the input file, return'
+ return os.sys.exit(1)
+ data = json.load(cfg_file)
+ cfg_file.close()
+
+ for test_case in data.iterkeys():
+ for key in data[test_case].iterkeys():
+ if isinstance(data[test_case][key], list) and key == 'testID':
+ for i in range(0, len(data[test_case][key])):
+ test_id_list.append(data[test_case][key][i])
+ return test_id_list
+
+ def ConfigForThisTestCase(self, data):
+ """Match if the configuration data is for current test case.
+
+ Args:
+ data: configuration data
+ Returns:
+ True: if the data is for current test case
+ False: if otherwise
+ """
+ for key in data.iterkeys():
+ if key == 'testID':
+ if self.test_info['testID'] in data[key]:
+ return True
+ else:
+ return False
+ return False
+
+ def ParseJSONConfigFile(self):
+ """Parse the JSON format configuration file.
+
+ The sturcture of a JSON file is as follows:
+ File format: parameter_names: string_values (or lists of values)
+ comment is defined in the comment tag (JSON does not support
+ comment).
+ 'Test_Case_Description' : {
+ 'comment': ['comments'],
+ 'testID': ['11843140', '111111', '222222'],
+ 'user' : 'root',
+ 'addr' : '192.168.1.4',
+ 'addr_ipv6' : 'None',
+ 'pwd' : 'google',
+ 'bruno_prompt' : 'gfibertv#',
+ 'title' : 'Download',
+ 'expected_version_id': '716006',
+ 'expected_version': 'bruno-koala-5',
+ 'downgrade_version': 'bruno-koala-4',
+ 'downgrade_version_id': '728001',
+ 'acs_url' : 'https://gfiber-acs-staging.appspot.com/cwmp',
+ 'jump_server' : 'jmp.googlefiber.net',
+ 'athena_user' : 'your_uname',
+ 'athena_pwd' : 'your_pwd'
+ }
+
+ Returns:
+ return True if configure file parsed successfully
+ """
+ try:
+ self.cfg_file = open(self.test_info['configFile'], 'r')
+ except IOError:
+ print 'Cannot open the input file, return'
+ return os.sys.exit(1)
+ data = json.load(self.cfg_file)
+ self.cfg_file.close()
+
+ test_id_matched = False
+ for test_case in data.iterkeys():
+ if not self.ConfigForThisTestCase(data[test_case]):
+ continue
+ for key in data[test_case].iterkeys():
+ if isinstance(data[test_case][key], (str, unicode)):
+ value = data[test_case][key]
+ if not value or value == 'None':
+ self.params[key] = None
+ else:
+ self.params[key] = value
+ elif isinstance(data[test_case][key], dict):
+ if (key == 'title' and
+ self.test_info['testID'] in data[test_case][key]):
+ self.params[key] = data[test_case][key][self.test_info['testID']]
+ self.test_info['key_word'] = self.params[key]
+ else:
+ self.params[key] = data[test_case][key]
+ elif isinstance(data[test_case][key], list):
+ if key == 'testID':
+ for i in range(0, len(data[test_case][key])):
+ test_id = data[test_case][key][i]
+ if str(self.test_info['testID']) == test_id:
+ test_id_matched = True
+ elif key == 'comment':
+ # do not process comment lines
+ continue
+ else:
+ self.params[key] = data[test_case][key]
+ else:
+ info = self.log.CreateErrorInfo(
+ 'Low', 'Warning: Configuration Parameter type unknown '
+ 'in file ' + self.test_info['configFile'] + ': '
+ + test_case + ':' + key)
+ self.log.SendLine(self.test_info, info)
+
+ if not test_id_matched:
+ info = self.log.CreateErrorInfo(
+ 'Low', 'Warning: No configuration found for this test '
+ 'case in file: ' + self.test_info['configFile'])
+ self.log.SendLine(self.test_info, info)
+ os.sys.exit(1)
+ return True
+
def ParseConfig(self):
"""Parse the configuration file for test case.
@@ -85,11 +237,14 @@
reuturn 1 if succeed
"""
# dictionary for params
- self.cfg_file = open(self.test_info['configFile'], 'r')
+ try:
+ self.cfg_file = open(self.test_info['configFile'], 'r')
+ except IOError:
+ print 'Cannot open the input file, return'
+ return os.sys.exit(1)
cfg_list = self.cfg_file.readlines()
test_id_matched = False
-
for line in cfg_list:
s = line.strip().strip('\n')
m = re.match('testID: ' + str(self.test_info['testID']), s)
@@ -138,6 +293,7 @@
'Low', 'Warning: No configuration found for this test case in file: '
+ self.test_info['configFile'])
self.log.SendLine(self.test_info, info)
+ os.sys.exit(1)
return True
def AddConfigParams(self, par='par', value='value'):
