Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 241F520049D for ; Wed, 9 Aug 2017 19:15:26 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id 22713169A49; Wed, 9 Aug 2017 17:15:26 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id BEC0C169A44 for ; Wed, 9 Aug 2017 19:15:24 +0200 (CEST) Received: (qmail 40237 invoked by uid 500); 9 Aug 2017 17:15:24 -0000 Mailing-List: contact commits-help@climate.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@climate.apache.org Delivered-To: mailing list commits@climate.apache.org Received: (qmail 40228 invoked by uid 99); 9 Aug 2017 17:15:23 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 09 Aug 2017 17:15:23 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id BCFC1E95C7; Wed, 9 Aug 2017 17:15:23 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: lewismc@apache.org To: commits@climate.apache.org Message-Id: X-Mailer: ASF-Git Admin Mailer Subject: climate git commit: CLIMATE-887 - test_local.py speed and style guide improvements Date: Wed, 9 Aug 2017 17:15:23 +0000 (UTC) archived-at: Wed, 09 Aug 2017 17:15:26 -0000 Repository: climate Updated Branches: refs/heads/master 6540643a0 -> 56989f578 CLIMATE-887 - test_local.py speed and style guide improvements - Change multiple tests (including test_get_netcdf_variable_names) to run setUp code once. - Use small static local file TestGetNetcdfVariableNames.nc as test data for test_get_netcdf_variable_names. - Clean up PEP8/257 warnings. Project: http://git-wip-us.apache.org/repos/asf/climate/repo Commit: http://git-wip-us.apache.org/repos/asf/climate/commit/56989f57 Tree: http://git-wip-us.apache.org/repos/asf/climate/tree/56989f57 Diff: http://git-wip-us.apache.org/repos/asf/climate/diff/56989f57 Branch: refs/heads/master Commit: 56989f5788bc6ef9e8b2a68bad62d7ed98b1e629 Parents: 6540643 Author: Justin L Authored: Wed Aug 9 01:28:31 2017 -0700 Committer: GitHub Committed: Wed Aug 9 01:28:31 2017 -0700 ---------------------------------------------------------------------- ocw/tests/TestGetNetcdfVariableNames.nc | Bin 0 -> 471996 bytes ocw/tests/test_local.py | 280 ++++++++++++++++----------- test_smoke.py | 4 +- 3 files changed, 166 insertions(+), 118 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/climate/blob/56989f57/ocw/tests/TestGetNetcdfVariableNames.nc ---------------------------------------------------------------------- diff --git a/ocw/tests/TestGetNetcdfVariableNames.nc b/ocw/tests/TestGetNetcdfVariableNames.nc new file mode 100644 index 0000000..13e2544 Binary files /dev/null and b/ocw/tests/TestGetNetcdfVariableNames.nc differ http://git-wip-us.apache.org/repos/asf/climate/blob/56989f57/ocw/tests/test_local.py ---------------------------------------------------------------------- diff --git a/ocw/tests/test_local.py b/ocw/tests/test_local.py index 0927f0f..0cca005 100644 --- a/ocw/tests/test_local.py +++ b/ocw/tests/test_local.py @@ -14,8 +14,9 @@ # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. +"""Tests for local.py, an OCW (netCDF, HDF5) file loading library.""" -# Needed Python 2/3 urllib compatability +# Needed Python 2/3 urllib compatibility try: from urllib.request import urlretrieve except ImportError: @@ -30,125 +31,150 @@ import numpy as np import ocw.data_source.local as local -class test_load_file(unittest.TestCase): +class TestLoadFile(unittest.TestCase): + """Tests for load_file method.""" + + @classmethod + def setUpClass(cls): + """Prepare a netCDF file once to use for all tests.""" + cls.file_path = create_netcdf_file() + + @classmethod + def tearDownClass(cls): + """Remove the no longer needed testing file at the end of the tests.""" + os.remove(cls.file_path) def setUp(self): - # Read netCDF file - self.file_path = create_netcdf_object() - self.netCDF_file = netCDF4.Dataset(self.file_path, 'r') - self.latitudes = self.netCDF_file.variables['latitude'][:] - self.longitudes = self.netCDF_file.variables['longitude'][:] - self.alt_lats = self.netCDF_file.variables['alt_lat'][:] - self.alt_lons = self.netCDF_file.variables['alt_lon'][:] - self.values = self.netCDF_file.variables['value'][:] - self.variable_name_list = ['latitude', - 'longitude', 'time', 'level', 'value'] + """Open and read in attributes of netCDF test file.""" + self.netcdf_file = netCDF4.Dataset(self.file_path, 'r') + self.latitudes = self.netcdf_file.variables['latitude'][:] + self.longitudes = self.netcdf_file.variables['longitude'][:] + self.alt_lats = self.netcdf_file.variables['alt_lat'][:] + self.alt_lons = self.netcdf_file.variables['alt_lon'][:] + self.values = self.netcdf_file.variables['value'][:] + self.variable_name_list = ['latitude', 'longitude', 'time', 'level', + 'value'] self.possible_value_name = ['latitude', 'longitude', 'time', 'level'] def tearDown(self): - os.remove(self.file_path) + """Close file object so that it may be re-read in the next test.""" + self.netcdf_file.close() def test_load_invalid_file_path(self): + """To test load_file an invalid path raises an exception.""" self.invalid_netcdf_path = '/invalid/path' with self.assertRaises(ValueError): local.load_file(file_path=self.invalid_netcdf_path, variable_name='test variable') def test_function_load_file_lats(self): - """To test load_file function for latitudes""" + """Test load_file function for latitudes.""" np.testing.assert_array_equal(local.load_file( self.file_path, "value").lats, self.latitudes) def test_function_load_file_lons(self): - """To test load_file function for longitudes""" + """Test load_file function for longitudes.""" np.testing.assert_array_equal(local.load_file( self.file_path, "value").lons, self.longitudes) def test_function_load_file_times(self): - """To test load_file function for times""" - newTimes = datetime.datetime(2001, 1, 1), datetime.datetime( + """Test load_file function for times.""" + new_times = datetime.datetime(2001, 1, 1), datetime.datetime( 2001, 2, 1), datetime.datetime(2001, 3, 1) np.testing.assert_array_equal(local.load_file( - self.file_path, "value").times, newTimes) + self.file_path, "value").times, new_times) def test_function_load_file_alt_lats(self): - """To test load_file function for lats with different variable names""" + """Test load_file function for lats with different variable names.""" np.testing.assert_array_equal(local.load_file( self.file_path, "value", lat_name="alt_lat").lats, self.alt_lats) def test_function_load_file_alt_lons(self): - """To test load_file function for lons with different variable names""" + """Test load_file function for lons with different variable names.""" np.testing.assert_array_equal(local.load_file( self.file_path, "value", lon_name="alt_lon").lons, self.alt_lons) def test_function_load_file_alt_times(self): - """To test load_file function for times with different variable names""" - newTimes = datetime.datetime(2001, 4, 1), datetime.datetime( + """Test load_file function for times with different variable names.""" + new_times = datetime.datetime(2001, 4, 1), datetime.datetime( 2001, 5, 1), datetime.datetime(2001, 6, 1) np.testing.assert_array_equal(local.load_file( - self.file_path, "value", time_name="alt_time").times, newTimes) + self.file_path, "value", time_name="alt_time").times, new_times) def test_function_load_file_values(self): - """To test load_file function for values""" + """Test load_file function for values.""" new_values = self.values[:, 0, :, :] self.assertTrue(np.allclose(local.load_file( self.file_path, "value").values, new_values)) def test_custom_dataset_name(self): - """Test adding a custom name to a dataset""" - ds = local.load_file(self.file_path, 'value', name='foo') - self.assertEqual(ds.name, 'foo') + """Test adding a custom name to a dataset.""" + dataset = local.load_file(self.file_path, 'value', name='foo') + self.assertEqual(dataset.name, 'foo') def test_dataset_origin(self): - ds = local.load_file(self.file_path, 'value', elevation_index=1) - expected_keys = set(['source', 'path', 'lat_name', 'lon_name', - 'time_name', 'elevation_index']) - self.assertEqual(set(ds.origin.keys()), expected_keys) - self.assertEqual(ds.origin['source'], 'local') + """Test that dataset origin is local.""" + dataset = local.load_file(self.file_path, 'value', elevation_index=1) + expected_keys = {'source', 'path', 'lat_name', 'lon_name', 'time_name', + 'elevation_index'} + self.assertEqual(set(dataset.origin.keys()), expected_keys) + self.assertEqual(dataset.origin['source'], 'local') class TestLoadMultipleFiles(unittest.TestCase): + """Tests for the load_multiple_files method.""" + + @classmethod + def setUpClass(cls): + """Prepare a netCDF file once to use for all tests.""" + cls.file_path = create_netcdf_file() + + @classmethod + def tearDownClass(cls): + """Remove the no longer needed testing file at the end of the tests.""" + os.remove(cls.file_path) def setUp(self): - # Read netCDF file - self.file_path = create_netcdf_object() - self.netCDF_file = netCDF4.Dataset(self.file_path, 'r') - self.latitudes = self.netCDF_file.variables['latitude'][:] - self.longitudes = self.netCDF_file.variables['longitude'][:] - self.values = self.netCDF_file.variables['value'][:] + """Open and read in attributes of netCDF test file.""" + self.netcdf_file = netCDF4.Dataset(self.file_path, 'r') + self.latitudes = self.netcdf_file.variables['latitude'][:] + self.longitudes = self.netcdf_file.variables['longitude'][:] + self.values = self.netcdf_file.variables['value'][:] self.variable_name_list = ['latitude', 'longitude', 'time', 'level', 'value'] self.possible_value_name = ['latitude', 'longitude', 'time', 'level'] def tearDown(self): - os.remove(self.file_path) + """Close file object so that it may be re-read in the next test.""" + self.netcdf_file.close() def test_function_load_multiple_files_data_name(self): + """Test load_multiple_file function for dataset name.""" dataset = local.load_multiple_files(self.file_path, "value") self.assertEqual([dataset[0].name], ['']) def test_function_load_multiple_files_lons(self): - """To test load_multiple_file function for longitudes""" + """Test load_multiple_file function for longitudes.""" dataset = local.load_multiple_files(self.file_path, "value") np.testing.assert_array_equal(dataset[0].lons, self.longitudes) def test_function_load_multiple_files_times(self): - """To test load_multiple_files function for times""" + """Test load_multiple_files function for times.""" dataset = local.load_multiple_files(self.file_path, "value") - newTimes = datetime.datetime(2001, 1, 1), datetime.datetime( + new_times = datetime.datetime(2001, 1, 1), datetime.datetime( 2001, 2, 1), datetime.datetime(2001, 3, 1) - np.testing.assert_array_equal(dataset[0].times, newTimes) + np.testing.assert_array_equal(dataset[0].times, new_times) def test_function_load_multiple_files_values(self): - """To test load_multiple_files function for values""" + """Test load_multiple_files function for values.""" new_values = self.values[:, 0, :, :] dataset = local.load_multiple_files( self.file_path, "value") self.assertTrue(np.allclose(dataset[0].values, new_values)) def test_load_multiple_files_custom_dataset_name(self): - """Test adding a custom name to a dataset""" + """Test adding a custom name to a dataset.""" dataset = local.load_multiple_files(self.file_path, "value", generic_dataset_name=True, @@ -156,104 +182,122 @@ class TestLoadMultipleFiles(unittest.TestCase): self.assertEqual(dataset[0].name, 'foo') def test_dataset_origin(self): + """Test that dataset origin is local.""" dataset = local.load_multiple_files(self.file_path, 'value') - expected_keys = set(['source', 'path', 'lat_name', 'lon_name', - 'time_name']) + expected_keys = {'source', 'path', 'lat_name', 'lon_name', 'time_name'} self.assertEqual(set(dataset[0].origin.keys()), expected_keys) self.assertEqual(dataset[0].origin['source'], 'local') class TestLoadDatasetFromMultipleNetcdfFiles(unittest.TestCase): - - def setUp(self): - self.file_path = create_netcdf_object() - self.netCDF_file = netCDF4.Dataset(self.file_path, 'r+') - self.latitudes = self.netCDF_file.variables['latitude'][:] - self.longitudes = self.netCDF_file.variables['longitude'][:] - self.alt_lats = self.netCDF_file.variables['alt_lat'][:] - self.alt_lons = self.netCDF_file.variables['alt_lon'][:] - self.values = self.netCDF_file.variables['value'][:] - self.variable_name_list = ['latitude', - 'longitude', 'time', 'level', 'value'] - self.possible_value_name = ['latitude', 'longitude', 'time', 'level'] - self.dataset = local.load_dataset_from_multiple_netcdf_files( + """Tests for load_dataset_from_multiple_netcdf_files method.""" + + @classmethod + def setUpClass(cls): + """Create, read in, and record attributes of a netCDF file for tests.""" + cls.file_path = create_netcdf_file() + cls.netcdf_file = netCDF4.Dataset(cls.file_path, 'r') + cls.latitudes = cls.netcdf_file.variables['latitude'][:] + cls.longitudes = cls.netcdf_file.variables['longitude'][:] + cls.alt_lats = cls.netcdf_file.variables['alt_lat'][:] + cls.alt_lons = cls.netcdf_file.variables['alt_lon'][:] + cls.values = cls.netcdf_file.variables['value'][:] + cls.variable_name_list = ['latitude', 'longitude', 'time', 'level', + 'value'] + cls.possible_value_name = ['latitude', 'longitude', 'time', 'level'] + cls.dataset = local.load_dataset_from_multiple_netcdf_files( variable_name='value', file_path='', - filename_pattern=[ - self.file_path]) - self.alt_dataset = local.load_dataset_from_multiple_netcdf_files( + filename_pattern=[cls.file_path]) + cls.alt_dataset = local.load_dataset_from_multiple_netcdf_files( variable_name='value', lat_name='alt_lat', lon_name='alt_lon', time_name='alt_time', file_path='', - filename_pattern=[ - self.file_path]) + filename_pattern=[cls.file_path]) - def tearDown(self): - os.remove(self.file_path) + @classmethod + def tearDownClass(cls): + """Remove the no longer needed testing file at the end of the tests.""" + cls.netcdf_file.close() + os.remove(cls.file_path) def test_variable_name(self): + """Test that dataset contains a variable value.""" self.assertEqual(self.dataset.variable, 'value') def test_function_load_dataset_from_multiple_netcdf_files_lats(self): - """To test load_multiple_files function for times""" + """Test load_multiple_files function for times.""" _, self.latitudes = np.meshgrid(self.longitudes, self.latitudes) np.testing.assert_array_equal(self.dataset.lats, self.latitudes) def test_function_load_dataset_from_multiple_netcdf_files_lons(self): - """To test load_multiple_files function for times""" + """Test load_multiple_files function for times.""" self.longitudes, _ = np.meshgrid(self.longitudes, self.latitudes) np.testing.assert_array_equal(self.dataset.lons, self.longitudes) def test_function_load_dataset_from_multiple_netcdf_files_times(self): - """To test load_multiple_files function for times""" - newTimes = datetime.datetime(2001, 1, 1), datetime.datetime( + """Test load_multiple_files function for times.""" + new_times = datetime.datetime(2001, 1, 1), datetime.datetime( 2001, 2, 1), datetime.datetime(2001, 3, 1) - np.testing.assert_array_equal(self.dataset.times, newTimes) + np.testing.assert_array_equal(self.dataset.times, new_times) def test_function_load_dataset_from_multiple_netcdf_files_alt_lats(self): - """To test load_multiple_files function for non-default lats""" + """Test load_multiple_files function for non-default lats.""" _, self.alt_lats = np.meshgrid(self.alt_lons, self.alt_lats) np.testing.assert_array_equal(self.alt_dataset.lats, self.alt_lats) def test_function_load_dataset_from_multiple_netcdf_files_alt_lons(self): - """To test load_multiple_files function for non-default lons""" + """Test load_multiple_files function for non-default lons.""" self.alt_lons, _ = np.meshgrid(self.alt_lons, self.alt_lats) np.testing.assert_array_equal(self.alt_dataset.lons, self.alt_lons) def test_function_load_dataset_from_multiple_netcdf_files_alt_times(self): - """To test load_multiple_files function for non-default times""" - newTimes = datetime.datetime(2001, 4, 1), datetime.datetime( + """Test load_multiple_files function for non-default times.""" + new_times = datetime.datetime(2001, 4, 1), datetime.datetime( 2001, 5, 1), datetime.datetime(2001, 6, 1) - np.testing.assert_array_equal(self.alt_dataset.times, newTimes) + np.testing.assert_array_equal(self.alt_dataset.times, new_times) def test_function_load_dataset_from_multiple_netcdf_files_values(self): - """To test load_multiple_files function for values""" + """Test load_multiple_files function for values.""" new_values = self.values[:, 0, :, :] self.assertTrue(np.allclose(self.dataset.values, new_values)) -class test_get_netcdf_variable_names(unittest.TestCase): - file_path = "http://zipper.jpl.nasa.gov/dist/" - test_model = "AFRICA_KNMI-RACMO2.2b_CTL_ERAINT_MM_50km_1989-2008_tasmax.nc" +class TestGetNetcdfVariableNames(unittest.TestCase): + """Tests for _get_netcdf_variable_name method retrieving variables. + + TestGetNetcdfVariableNames.nc" is a subset of data from + https://zipper.jpl.nasa.gov/dist/AFRICA_KNMI-RACMO2.2b_CTL_ERAINT_MM_50km_1989-2008_tasmax.nc + Test data obtained with: + ncea -d time,0,0 AFRICA_KNMI-[...]_tasmax.nc \ + TestGetNetcdfVariableNames.nc + """ + + @classmethod + def setUpClass(cls): + """Create a netCDF file with invalid dimensions for tests.""" + cls.test_model = "TestGetNetcdfVariableNames.nc" + cls.invalid_netcdf_path = create_invalid_dimensions_netcdf_file() def setUp(self): - urlretrieve(self.file_path + self.test_model, self.test_model) - self.invalid_netcdf_path = create_invalid_dimensions_netcdf_object() + """Open a valid netCDF file for use in the test.""" self.netcdf = netCDF4.Dataset(self.test_model, mode='r') def tearDown(self): - os.remove(self.invalid_netcdf_path) - os.remove(self.test_model) + """Close file object so that it may be re-read in the next test.""" + self.netcdf.close() def test_valid_latitude(self): + """Test that a latitude variable (rlat) can be found in netCDF file.""" self.lat = local._get_netcdf_variable_name(local.LAT_NAMES, self.netcdf, "tasmax") self.assertEquals(self.lat, "rlat") def test_invalid_dimension_latitude(self): + """Test than an invalid latitude variable can be found in file.""" self.netcdf = netCDF4.Dataset(self.invalid_netcdf_path, mode='r') self.lat = local._get_netcdf_variable_name(local.LAT_NAMES, self.netcdf, @@ -261,6 +305,7 @@ class test_get_netcdf_variable_names(unittest.TestCase): self.assertEquals(self.lat, "latitude") def test_dimension_variable_name_mismatch(self): + """Test that mismatched latitude variables are found as latitude.""" self.netcdf = netCDF4.Dataset(self.invalid_netcdf_path, mode='r') self.lat = local._get_netcdf_variable_name( ["lat_dim"] + local.LAT_NAMES, @@ -269,31 +314,33 @@ class test_get_netcdf_variable_names(unittest.TestCase): self.assertEquals(self.lat, "latitude") def test_no_match_latitude(self): + """Test that retrieving a nonexistent variable name raises exception.""" with self.assertRaises(ValueError): self.lat = local._get_netcdf_variable_name(['notAVarName'], self.netcdf, "tasmax") -def create_netcdf_object(): +def create_netcdf_file(): + """Create a temporary netCDF file with data used for testing.""" # To create the temporary netCDF file file_path = '/tmp/temporaryNetcdf.nc' - netCDF_file = netCDF4.Dataset(file_path, 'w', format='NETCDF4') + netcdf_file = netCDF4.Dataset(file_path, 'w', format='NETCDF4') # To create dimensions - netCDF_file.createDimension('lat_dim', 5) - netCDF_file.createDimension('lon_dim', 5) - netCDF_file.createDimension('time_dim', 3) - netCDF_file.createDimension('level_dim', 2) + netcdf_file.createDimension('lat_dim', 5) + netcdf_file.createDimension('lon_dim', 5) + netcdf_file.createDimension('time_dim', 3) + netcdf_file.createDimension('level_dim', 2) # To create variables - latitudes = netCDF_file.createVariable('latitude', 'd', ('lat_dim',)) - longitudes = netCDF_file.createVariable('longitude', 'd', ('lon_dim',)) - times = netCDF_file.createVariable('time', 'd', ('time_dim',)) + latitudes = netcdf_file.createVariable('latitude', 'd', ('lat_dim',)) + longitudes = netcdf_file.createVariable('longitude', 'd', ('lon_dim',)) + times = netcdf_file.createVariable('time', 'd', ('time_dim',)) # unusual variable names to test optional arguments for Dataset constructor - alt_lats = netCDF_file.createVariable('alt_lat', 'd', ('lat_dim',)) - alt_lons = netCDF_file.createVariable('alt_lon', 'd', ('lon_dim',)) - alt_times = netCDF_file.createVariable('alt_time', 'd', ('time_dim',)) - levels = netCDF_file.createVariable('level', 'd', ('level_dim',)) - values = netCDF_file.createVariable('value', 'd', + alt_lats = netcdf_file.createVariable('alt_lat', 'd', ('lat_dim',)) + alt_lons = netcdf_file.createVariable('alt_lon', 'd', ('lon_dim',)) + alt_times = netcdf_file.createVariable('alt_time', 'd', ('time_dim',)) + levels = netcdf_file.createVariable('level', 'd', ('level_dim',)) + values = netcdf_file.createVariable('value', 'd', ('time_dim', 'level_dim', 'lat_dim', @@ -323,29 +370,30 @@ def create_netcdf_object(): levels[:] = levels_data values[:] = values_data # Assign time info to time variable - netCDF_file.variables['time'].units = 'months since 2001-01-01 00:00:00' - netCDF_file.variables[ + netcdf_file.variables['time'].units = 'months since 2001-01-01 00:00:00' + netcdf_file.variables[ 'alt_time'].units = 'months since 2001-04-01 00:00:00' - netCDF_file.variables['value'].units = 'foo_units' - netCDF_file.close() + netcdf_file.variables['value'].units = 'foo_units' + netcdf_file.close() return file_path -def create_invalid_dimensions_netcdf_object(): +def create_invalid_dimensions_netcdf_file(): + """Create a temporary netCDF file with invalid dimensions for testing.""" # To create the temporary netCDF file file_path = '/tmp/temporaryNetcdf.nc' - netCDF_file = netCDF4.Dataset(file_path, 'w', format='NETCDF4') + netcdf_file = netCDF4.Dataset(file_path, 'w', format='NETCDF4') # To create dimensions - netCDF_file.createDimension('lat_dim', 5) - netCDF_file.createDimension('lon_dim', 5) - netCDF_file.createDimension('time_dim', 3) - netCDF_file.createDimension('level_dim', 2) + netcdf_file.createDimension('lat_dim', 5) + netcdf_file.createDimension('lon_dim', 5) + netcdf_file.createDimension('time_dim', 3) + netcdf_file.createDimension('level_dim', 2) # To create variables - latitudes = netCDF_file.createVariable('latitude', 'd', ('lat_dim',)) - longitudes = netCDF_file.createVariable('longitude', 'd', ('lon_dim',)) - times = netCDF_file.createVariable('time', 'd', ('time_dim',)) - levels = netCDF_file.createVariable('level', 'd', ('level_dim',)) - values = netCDF_file.createVariable('value', + latitudes = netcdf_file.createVariable('latitude', 'd', ('lat_dim',)) + longitudes = netcdf_file.createVariable('longitude', 'd', ('lon_dim',)) + times = netcdf_file.createVariable('time', 'd', ('time_dim',)) + levels = netcdf_file.createVariable('level', 'd', ('level_dim',)) + values = netcdf_file.createVariable('value', 'd', ('level_dim', 'time_dim', @@ -371,8 +419,8 @@ def create_invalid_dimensions_netcdf_object(): levels[:] = flevels values[:] = fvalues # Assign time info to time variable - netCDF_file.variables['time'].units = 'months since 2001-01-01 00:00:00' - netCDF_file.close() + netcdf_file.variables['time'].units = 'months since 2001-01-01 00:00:00' + netcdf_file.close() return file_path http://git-wip-us.apache.org/repos/asf/climate/blob/56989f57/test_smoke.py ---------------------------------------------------------------------- diff --git a/test_smoke.py b/test_smoke.py index f08d72a..269f225 100644 --- a/test_smoke.py +++ b/test_smoke.py @@ -17,7 +17,7 @@ from pkg_resources import VersionConflict, DistributionNotFound, \ require -from ocw.tests.test_local import create_netcdf_object +from ocw.tests.test_local import create_netcdf_file from ocw.data_source import local from ocw import dataset_processor as dsp import os @@ -73,7 +73,7 @@ def check_dataset_loading(): ''' Try loading test dataset ''' dataset = None try: - file_path = create_netcdf_object() + file_path = create_netcdf_file() dataset = local.load_file(file_path, variable_name='value') except Exception as e: fail("\nDataset loading")