diff --git a/integrations/acquisition/covidcast/test_csv_uploading.py b/integrations/acquisition/covidcast/test_csv_uploading.py
index 397dc0a73..bb65e10d8 100644
--- a/integrations/acquisition/covidcast/test_csv_uploading.py
+++ b/integrations/acquisition/covidcast/test_csv_uploading.py
@@ -8,6 +8,8 @@
 
 # third party
 import mysql.connector
+import pandas as pd
+import numpy as np
 
 # first party
 from delphi_utils import Nans
@@ -52,6 +54,26 @@ def tearDown(self):
     self.cur.close()
     self.cnx.close()
 
+  @staticmethod
+  def apply_lag(expected_epidata):
+    expected_issue_day=date.today()
+    expected_issue=expected_issue_day.strftime("%Y%m%d")
+    for dct in expected_epidata:
+      dct['issue'] = int(expected_issue)
+      time_value_day = date(year=dct['time_value'] // 10000,
+                            month=dct['time_value'] % 10000 // 100,
+                            day= dct['time_value'] % 100)
+      expected_lag = (expected_issue_day - time_value_day).days
+      dct['lag'] = expected_lag
+    return expected_epidata
+
+  def verify_timestamps_and_defaults(self):
+    self.cur.execute('select value_updated_timestamp, direction_updated_timestamp, direction from covidcast')
+    for value_updated_timestamp, direction_updated_timestamp, direction in self.cur:
+      self.assertGreater(value_updated_timestamp, 0)
+      self.assertEqual(direction_updated_timestamp, 0)
+      self.assertIsNone(direction)
+
   def test_uploading(self):
     """Scan, parse, upload, archive, serve, and fetch a covidcast signal."""
 
@@ -64,299 +86,250 @@ def test_uploading(self):
     log_file_directory = "/var/log/"
     os.makedirs(source_receiving_dir, exist_ok=True)
     os.makedirs(log_file_directory, exist_ok=True)
-
-    # valid
-    with open(source_receiving_dir + '/20200419_state_test.csv', 'w') as f:
-      f.write('geo_id,val,se,sample_size,missing_val,missing_se,missing_sample_size\n')
-      f.write(f'ca,1,0.1,10,{Nans.NOT_MISSING},{Nans.NOT_MISSING},{Nans.NOT_MISSING}\n')
-      f.write(f'tx,2,0.2,20,{Nans.NOT_MISSING},{Nans.NOT_MISSING},{Nans.NOT_MISSING}\n')
-      f.write(f'fl,3,0.3,30,{Nans.NOT_MISSING},{Nans.NOT_MISSING},{Nans.NOT_MISSING}\n')
-
-    # valid, old style no missing cols should have intelligent defaults
-    with open(source_receiving_dir + '/20200419_state_test_no_missing.csv', 'w') as f:
-      f.write('geo_id,val,se,sample_size\n')
-      f.write('ca,1,0.1,10\n')
-      f.write('tx,NA,0.2,20\n')
-      f.write('wa,3,0.3,30\n')
-
-    # invalid, missing with an inf value
-    with open(source_receiving_dir + '/20200419_state_test_missing1.csv', 'w') as f:
-      f.write('geo_id,val,se,sample_size,missing_val,missing_se,missing_sample_size\n')
-      f.write(f'fl,inf,0.3,30,{Nans.OTHER},{Nans.NOT_MISSING},{Nans.NOT_MISSING}\n')
-
-    # invalid, missing with an incorrect missing code
-    with open(source_receiving_dir + '/20200419_state_test_missing2.csv', 'w') as f:
-      f.write('geo_id,val,se,sample_size,missing_val,missing_se,missing_sample_size\n')
-      f.write(f'tx,NA,0.2,20,{Nans.NOT_MISSING},{Nans.NOT_MISSING},{Nans.NOT_MISSING}\n')
-
-    # invalid, no missing with an incorrect missing code
-    with open(source_receiving_dir + '/20200419_state_test_missing3.csv', 'w') as f:
-      f.write('geo_id,val,se,sample_size,missing_val,missing_se,missing_sample_size\n')
-      f.write(f'wa,3,0.3,30,{Nans.OTHER},{Nans.NOT_MISSING},{Nans.NOT_MISSING}\n')
-
-    # valid wip
-    with open(source_receiving_dir + '/20200419_state_wip_prototype.csv', 'w') as f:
-      f.write('geo_id,val,se,sample_size,missing_val,missing_se,missing_sample_size\n')
-      f.write(f'me,10,0.01,100,{Nans.NOT_MISSING},{Nans.NOT_MISSING},{Nans.NOT_MISSING}\n')
-      f.write(f'nd,20,0.02,200,{Nans.NOT_MISSING},{Nans.NOT_MISSING},{Nans.NOT_MISSING}\n')
-      f.write(f'wa,30,0.03,300,{Nans.NOT_MISSING},{Nans.NOT_MISSING},{Nans.NOT_MISSING}\n')
-
-    # invalid
-    with open(source_receiving_dir + '/20200419_state_wip_really_long_name_that_will_be_accepted.csv', 'w') as f:
-      f.write('geo_id,val,se,sample_size,missing_val,missing_se,missing_sample_size\n')
-      f.write(f'pa,100,5.4,624,{Nans.NOT_MISSING},{Nans.NOT_MISSING},{Nans.NOT_MISSING}\n')
-
-    # invalid
-    with open(source_receiving_dir + '/20200419_state_wip_really_long_name_that_will_get_truncated_lorem_ipsum_dolor_sit_amet.csv', 'w') as f:
-      f.write('geo_id,val,se,sample_size,missing_val,missing_se,missing_sample_size\n')
-      f.write(f'pa,100,5.4,624,{Nans.NOT_MISSING}, {Nans.NOT_MISSING}, {Nans.NOT_MISSING}\n')
-
-    # invalid
-    with open(source_receiving_dir + '/20200420_state_test.csv', 'w') as f:
-      f.write('this,header,is,wrong\n')
-
-    # invalid
-    with open(source_receiving_dir + '/hello.csv', 'w') as f:
-      f.write('file name is wrong\n')
-
-    # upload CSVs
     # TODO: use an actual argparse object for the args instead of a MagicMock
     args = MagicMock(
-        log_file=log_file_directory +
-        "output.log",
-        data_dir=data_dir,
-        is_wip_override=False,
-        not_wip_override=False,
-        specific_issue_date=False)
-    main(args)
+          log_file=log_file_directory +
+          "output.log",
+          data_dir=data_dir,
+          is_wip_override=False,
+          not_wip_override=False,
+          specific_issue_date=False)
+    uploader_column_rename = {"geo_id": "geo_value", "val": "value", "se": "stderr", "missing_val": "missing_value", "missing_se": "missing_stderr"}
+
+
+    with self.subTest("Valid CSV with correct missing columns"):
+      values = pd.DataFrame({
+        "geo_id": ["ca", "fl", "tx"],
+        "val": [1.0, 2.0, 3.0],
+        "se": [0.1, 0.2, 0.3],
+        "sample_size": [10.0, 20.0, 30.0],
+        "missing_val": [Nans.NOT_MISSING] * 3,
+        "missing_se": [Nans.NOT_MISSING] * 3,
+        "missing_sample_size": [Nans.NOT_MISSING] * 3
+      })
+      signal_name = "test"
+      values.to_csv(source_receiving_dir + f'/20200419_state_{signal_name}.csv', index=False)
+
+      # upload CSVs
+      main(args)
+      response = Epidata.covidcast('src-name', signal_name, 'day', 'state', 20200419, '*')
+
+      expected_values = pd.concat([values, pd.DataFrame({ "time_value": [20200419] * 3, "signal": [signal_name] * 3, "direction": [None] * 3})], axis=1).rename(columns=uploader_column_rename).to_dict(orient="records")
+      expected_response = {'result': 1, 'epidata': self.apply_lag(expected_values), 'message': 'success'}
+
+      self.assertEqual(response, expected_response)
+      self.verify_timestamps_and_defaults()
+
+      # Verify that files were archived
+      path = data_dir + f'/archive/successful/src-name/20200419_state_test.csv.gz'
+      self.assertIsNotNone(os.stat(path))
 
-    # request CSV data from the API
-    response = Epidata.covidcast(
-        'src-name', 'test', 'day', 'state', 20200419, '*')
+      self.tearDown()
+      self.setUp()
+
+
+    with self.subTest("Valid CSV with no missing columns should set intelligent defaults"):
+      values = pd.DataFrame({
+        "geo_id": ["ca", "fl", "tx"],
+        "val": [None, 2.0, 3.0],
+        "se": [0.1, None, 0.3],
+        "sample_size": [10.0, 20.0, None]
+      }, dtype=object)
+      signal_name = "test_no_missing_cols"
+      values.to_csv(source_receiving_dir + f'/20200419_state_{signal_name}.csv', index=False)
+
+      # upload CSVs
+      main(args)
+      response = Epidata.covidcast('src-name', signal_name, 'day', 'state', 20200419, '*')
+
+      expected_values = pd.concat([values, pd.DataFrame({
+        "time_value": [20200419] * 3,
+        "signal": [signal_name] * 3,
+        "direction": [None] * 3,
+        "missing_value": [Nans.OTHER] + [Nans.NOT_MISSING] * 2,
+        "missing_stderr": [Nans.NOT_MISSING, Nans.OTHER, Nans.NOT_MISSING],
+        "missing_sample_size": [Nans.NOT_MISSING] * 2 + [Nans.OTHER]
+      })], axis=1).rename(columns=uploader_column_rename).to_dict(orient="records")
+      expected_response = {'result': 1, 'epidata': self.apply_lag(expected_values), 'message': 'success'}
+
+      self.assertEqual(response, expected_response)
+      self.verify_timestamps_and_defaults()
+
+      self.tearDown()
+      self.setUp()
+
+
+    with self.subTest("Invalid, missing with an inf value"):
+      values = pd.DataFrame({
+        "geo_id": ["tx"],
+        "val": [np.inf],
+        "se": [0.3],
+        "sample_size": [None],
+        "missing_value": [Nans.OTHER],
+        "missing_stderr": [Nans.NOT_MISSING],
+        "missing_sample_size": [Nans.NOT_MISSING]
+      })
+      signal_name = "test_with_inf"
+      values.to_csv(source_receiving_dir + f'/20200419_state_{signal_name}.csv', index=False)
+
+      # upload CSVs
+      main(args)
+      response = Epidata.covidcast('src-name', signal_name, 'day', 'state', 20200419, '*')
+
+      expected_response = {'result': -2, 'message': 'no results'}
+
+      self.assertEqual(response, expected_response)
+      self.verify_timestamps_and_defaults()
+      self.tearDown()
+      self.setUp()
+
+
+    with self.subTest("Valid, missing with incorrect missing codes, fixed by acquisition"):
+      values = pd.DataFrame({
+        "geo_id": ["tx"],
+        "val": [None],
+        "se": [0.3],
+        "sample_size": [30.0],
+        "missing_val": [Nans.NOT_MISSING],
+        "missing_se": [Nans.NOT_MISSING],
+        "missing_sample_size": [Nans.OTHER]
+      }).replace({np.nan:None})
+      signal_name = "test_incorrect_missing_codes"
+      values.to_csv(source_receiving_dir + f'/20200419_state_{signal_name}.csv', index=False)
+
+      # upload CSVs
+      main(args)
+      response = Epidata.covidcast('src-name', signal_name, 'day', 'state', 20200419, '*')
+
+      expected_values_df = pd.concat([values, pd.DataFrame({
+        "time_value": [20200419],
+        "signal": [signal_name],
+        "direction": [None]})], axis=1).rename(columns=uploader_column_rename)
+      expected_values_df["missing_value"].iloc[0] = Nans.OTHER
+      expected_values_df["missing_sample_size"].iloc[0] = Nans.NOT_MISSING
+      expected_values = expected_values_df.to_dict(orient="records")
+      expected_response = {'result': 1, 'epidata': self.apply_lag(expected_values), 'message': 'success'}
+
+      self.assertEqual(response, expected_response)
+      self.verify_timestamps_and_defaults()
+
+      self.tearDown()
+      self.setUp()
+
+
+    with self.subTest("Valid wip"):
+      values = pd.DataFrame({
+        "geo_id": ["me", "nd", "wa"],
+        "val": [10.0, 20.0, 30.0],
+        "se": [0.01, 0.02, 0.03],
+        "sample_size": [100.0, 200.0, 300.0],
+        "missing_val": [Nans.NOT_MISSING] * 3,
+        "missing_se": [Nans.NOT_MISSING] * 3,
+        "missing_sample_size": [Nans.NOT_MISSING] * 3
+      })
+      signal_name = "wip_prototype"
+      values.to_csv(source_receiving_dir + f'/20200419_state_{signal_name}.csv', index=False)
+
+      # upload CSVs
+      main(args)
+      response = Epidata.covidcast('src-name', signal_name, 'day', 'state', 20200419, '*')
+
+      expected_values = pd.concat([values, pd.DataFrame({
+        "time_value": [20200419] * 3,
+        "signal": [signal_name] * 3,
+        "direction": [None] * 3
+      })], axis=1).rename(columns=uploader_column_rename).to_dict(orient="records")
+      expected_response = {'result': 1, 'epidata': self.apply_lag(expected_values), 'message': 'success'}
+
+      self.assertEqual(response, expected_response)
+      self.verify_timestamps_and_defaults()
+
+      # Verify that files were archived
+      path = data_dir + f'/archive/successful/src-name/20200419_state_wip_prototype.csv.gz'
+      self.assertIsNotNone(os.stat(path))
 
+      self.tearDown()
+      self.setUp()
 
-    expected_issue_day=date.today()
-    expected_issue=expected_issue_day.strftime("%Y%m%d")
-    def apply_lag(expected_epidata):
-      for dct in expected_epidata:
-        dct['issue'] = int(expected_issue)
-        time_value_day = date(year=dct['time_value'] // 10000,
-                              month=dct['time_value'] % 10000 // 100,
-                              day= dct['time_value'] % 100)
-        expected_lag = (expected_issue_day - time_value_day).days
-        dct['lag'] = expected_lag
-      return expected_epidata
-
-    # verify data matches the CSV
-    # NB these are ordered by geo_value
-    self.assertEqual(response, {
-      'result': 1,
-      'epidata': apply_lag([
-        {
-          'time_value': 20200419,
-          'geo_value': 'ca',
-          'value': 1,
-          'stderr': 0.1,
-          'sample_size': 10,
-          'direction': None,
-          'signal': 'test',
-          'missing_value': Nans.NOT_MISSING,
-          'missing_stderr': Nans.NOT_MISSING,
-          'missing_sample_size': Nans.NOT_MISSING,
-        },
-        {
-          'time_value': 20200419,
-          'geo_value': 'fl',
-          'value': 3,
-          'stderr': 0.3,
-          'sample_size': 30,
-          'direction': None,
-          'signal': 'test',
-          'missing_value': Nans.NOT_MISSING,
-          'missing_stderr': Nans.NOT_MISSING,
-          'missing_sample_size': Nans.NOT_MISSING,
-        },
-        {
-          'time_value': 20200419,
-          'geo_value': 'tx',
-          'value': 2,
-          'stderr': 0.2,
-          'sample_size': 20,
-          'direction': None,
-          'signal': 'test',
-          'missing_value': Nans.NOT_MISSING,
-          'missing_stderr': Nans.NOT_MISSING,
-          'missing_sample_size': Nans.NOT_MISSING,
-        },
-    ]),
-      'message': 'success',
-    })
-
-    # request CSV data from the API on the test with missing values
-    response = Epidata.covidcast(
-      'src-name', 'test_no_missing', 'day', 'state', 20200419, '*')
-
-    # verify data matches the CSV
-    # NB these are ordered by geo_value
-    self.assertEqual(response, {
-      'result': 1,
-      'epidata': apply_lag([
-        {
-          'time_value': 20200419,
-          'geo_value': 'ca',
-          'value': 1,
-          'stderr': 0.1,
-          'sample_size': 10,
-          'direction': None,
-          'signal': 'test_no_missing',
-          'missing_value': Nans.NOT_MISSING,
-          'missing_stderr': Nans.NOT_MISSING,
-          'missing_sample_size': Nans.NOT_MISSING,
-        },
-        {
-          'time_value': 20200419,
-          'geo_value': 'tx',
-          'value': None,
-          'stderr': 0.2,
-          'sample_size': 20,
-          'direction': None,
-          'signal': 'test_no_missing',
-          'missing_value': Nans.OTHER,
-          'missing_stderr': Nans.NOT_MISSING,
-          'missing_sample_size': Nans.NOT_MISSING,
-        },
-        {
-          'time_value': 20200419,
-          'geo_value': 'wa',
-          'value': 3,
-          'stderr': 0.3,
-          'sample_size': 30,
-          'direction': None,
-          'signal': 'test_no_missing',
-          'missing_value': Nans.NOT_MISSING,
-          'missing_stderr': Nans.NOT_MISSING,
-          'missing_sample_size': Nans.NOT_MISSING,
-        },
-       ]),
-      'message': 'success',
-    })
-
-    # invalid missing files
-    response = Epidata.covidcast(
-      'src-name', 'test_missing1', 'day', 'state', 20200419, '*')
-    self.assertEqual(response, {
-      'result': -2,
-      'message': 'no results',
-    })
-    response = Epidata.covidcast(
-      'src-name', 'test_missing2', 'day', 'state', 20200419, '*')
-    self.assertEqual(response, {
-      'result': -2,
-      'message': 'no results',
-    })
-    response = Epidata.covidcast(
-      'src-name', 'test_missing3', 'day', 'state', 20200419, '*')
-    self.assertEqual(response, {
-      'result': -2,
-      'message': 'no results',
-    })
-
-    # request CSV data from the API on WIP signal
-    response = Epidata.covidcast(
-      'src-name', 'wip_prototype', 'day', 'state', 20200419, '*')
-
-    # verify data matches the CSV
-    # NB these are ordered by geo_value
-    self.assertEqual(response, {
-      'result': 1,
-      'epidata': apply_lag([
-        {
-          'time_value': 20200419,
-          'geo_value': 'me',
-          'value': 10,
-          'stderr': 0.01,
-          'sample_size': 100,
-          'direction': None,
-          'signal': 'wip_prototype',
-          'missing_value': Nans.NOT_MISSING,
-          'missing_stderr': Nans.NOT_MISSING,
-          'missing_sample_size': Nans.NOT_MISSING,
-        },
-        {
-          'time_value': 20200419,
-          'geo_value': 'nd',
-          'value': 20,
-          'stderr': 0.02,
-          'sample_size': 200,
-          'direction': None,
-          'signal': 'wip_prototype',
-          'missing_value': Nans.NOT_MISSING,
-          'missing_stderr': Nans.NOT_MISSING,
-          'missing_sample_size': Nans.NOT_MISSING,
-        },
-        {
-          'time_value': 20200419,
-          'geo_value': 'wa',
-          'value': 30,
-          'stderr': 0.03,
-          'sample_size': 300,
-          'direction': None,
-          'signal': 'wip_prototype',
-          'missing_value': Nans.NOT_MISSING,
-          'missing_stderr': Nans.NOT_MISSING,
-          'missing_sample_size': Nans.NOT_MISSING,
-        },
-       ]),
-      'message': 'success',
-    })
-
-    # request CSV data from the API on the signal with name length 32<x<64
-    response = Epidata.covidcast(
-      'src-name', 'wip_really_long_name_that_will_be_accepted', 'day', 'state', 20200419, '*')
-
-    # verify data matches the CSV
-    self.assertEqual(response, {
-      'result': 1,
-      'message': 'success',
-      'epidata': apply_lag([
-        {
-          'time_value': 20200419,
-          'geo_value': 'pa',
-          'value': 100,
-          'stderr': 5.4,
-          'sample_size': 624,
-          'direction': None,
-          'signal': 'wip_really_long_name_that_will_be_accepted',\
-          'missing_value': Nans.NOT_MISSING,
-          'missing_stderr': Nans.NOT_MISSING,
-          'missing_sample_size': Nans.NOT_MISSING,
-        },
-      ])
-    })
-
-    # request CSV data from the API on the long-named signal
-    response = Epidata.covidcast(
-      'src-name', 'wip_really_long_name_that_will_get_truncated_lorem_ipsum_dolor_s', 'day', 'state', 20200419, '*')
-
-    # verify data matches the CSV
-    # if the CSV failed correctly there should be no results
-    self.assertEqual(response, {
-      'result': -2,
-      'message': 'no results',
-    })
-
-    # verify timestamps and default values are reasonable
-    self.cur.execute('select value_updated_timestamp, direction_updated_timestamp, direction from covidcast')
-    for value_updated_timestamp, direction_updated_timestamp, direction in self.cur:
-      self.assertGreater(value_updated_timestamp, 0)
-      self.assertEqual(direction_updated_timestamp, 0)
-      self.assertIsNone(direction)
 
-    # verify that the CSVs were archived
-    for sig in ["test","wip_prototype"]:
-      path = data_dir + f'/archive/successful/src-name/20200419_state_{sig}.csv.gz'
+    with self.subTest("Valid signal with name length 32<x<64"):
+      values = pd.DataFrame({
+        "geo_id": ["pa"],
+        "val": [100.0],
+        "se": [5.4],
+        "sample_size": [624.0],
+        "missing_val": [Nans.NOT_MISSING],
+        "missing_se": [Nans.NOT_MISSING],
+        "missing_sample_size": [Nans.NOT_MISSING]
+      })
+      signal_name = "wip_really_long_name_that_will_be_accepted"
+      values.to_csv(source_receiving_dir + f'/20200419_state_{signal_name}.csv', index=False)
+
+      # upload CSVs
+      main(args)
+      response = Epidata.covidcast('src-name', signal_name, 'day', 'state', 20200419, '*')
+
+      expected_values = pd.concat([values, pd.DataFrame({
+        "time_value": [20200419],
+        "signal": [signal_name],
+        "direction": [None]
+      })], axis=1).rename(columns=uploader_column_rename).to_dict(orient="records")
+      expected_response = {'result': 1, 'epidata': self.apply_lag(expected_values), 'message': 'success'}
+
+      self.assertEqual(response, expected_response)
+      self.verify_timestamps_and_defaults()
+
+      self.tearDown()
+      self.setUp()
+
+
+    with self.subTest("Invalid signal with a too-long name"):
+      values = pd.DataFrame({
+        "geo_id": ["pa"],
+        "val": [100.0],
+        "se": [5.4],
+        "sample_size": [624.0],
+        "missing_val": [Nans.NOT_MISSING],
+        "missing_se": [Nans.NOT_MISSING],
+        "missing_sample_size": [Nans.NOT_MISSING]
+      })
+      signal_name = "wip_really_long_name_that_will_get_truncated_lorem_ipsum_dolor_sit_amet"
+      values.to_csv(source_receiving_dir + f'/20200419_state_{signal_name}.csv', index=False)
+
+      # upload CSVs
+      main(args)
+      response = Epidata.covidcast('src-name', signal_name, 'day', 'state', 20200419, '*')
+
+      expected_response = {'result': -2, 'message': 'no results'}
+
+      self.assertEqual(response, expected_response)
+      self.verify_timestamps_and_defaults()
+
+      self.tearDown()
+      self.setUp()
+
+
+    with self.subTest("Invalid file with a wrong header"):
+      with open(source_receiving_dir + '/20200420_state_test.csv', 'w') as f:
+        f.write('this,header,is,wrong\n')
+
+      main(args)
+
+      path = data_dir + '/archive/failed/src-name/20200420_state_test.csv'
       self.assertIsNotNone(os.stat(path))
-    path = data_dir + '/archive/failed/src-name/20200420_state_test.csv'
-    self.assertIsNotNone(os.stat(path))
-    path = data_dir + '/archive/failed/unknown/hello.csv'
-    self.assertIsNotNone(os.stat(path))
+
+      self.tearDown()
+      self.setUp()
+
+
+    with self.subTest("Invalid file with a wrong name"):
+      with open(source_receiving_dir + '/hello.csv', 'w') as f:
+        f.write('file name is wrong\n')
+
+      main(args)
+
+      path = data_dir + '/archive/failed/unknown/hello.csv'
+      self.assertIsNotNone(os.stat(path))
+
+      self.tearDown()
+      self.setUp()
diff --git a/src/acquisition/covidcast/csv_importer.py b/src/acquisition/covidcast/csv_importer.py
index f55327d85..05669cb82 100644
--- a/src/acquisition/covidcast/csv_importer.py
+++ b/src/acquisition/covidcast/csv_importer.py
@@ -38,6 +38,16 @@ class CsvImporter:
   MIN_YEAR = 2019
   MAX_YEAR = 2030
 
+  DTYPES = {
+    "geo_id": str,
+    "val": float,
+    "se": float,
+    "sample_size": float,
+    "missing_val": int,
+    "missing_se": int,
+    "missing_sample_size": int
+  }
+
   # NOTE: this should be a Python 3.7+ `dataclass`, but the server is on 3.4
   # See https://docs.python.org/3/library/dataclasses.html
   class RowValues:
@@ -183,10 +193,9 @@ def floaty_int(value):
     """
 
     float_value = float(value)
-    int_value = round(float_value)
-    if float_value != int_value:
+    if not float_value.is_integer():
       raise ValueError('not an int: "%s"' % str(value))
-    return int_value
+    return int(float_value)
 
   @staticmethod
   def maybe_apply(func, quantity):
@@ -212,7 +221,7 @@ def validate_quantity(row, attr_quantity):
       return "Error"
 
   @staticmethod
-  def validate_missing_code(row, attr_quantity, attr_name):
+  def validate_missing_code(row, attr_quantity, attr_name, filepath=None, logger=None):
     """Take a row and validate the missing code associated with
     a quantity (e.g., val, se, stderr).
 
@@ -221,27 +230,30 @@ def validate_missing_code(row, attr_quantity, attr_name):
     to infer missing codes except for a very simple cases; the default
     is to produce an error so that the issue can be fixed in indicators.
     """
-    if hasattr(row, "missing_" + attr_name):
-      missing_entry = getattr(row, "missing_" + attr_name)
-      try:
-        missing_entry = int(missing_entry)
-      except ValueError:
-        return None
-      # A missing code should never contradict the quantity being present,
-      # since that will be filtered in the export_to_csv util in
-      # covidcast-indicators; nonetheless this code is here for safety.
-      if attr_quantity is not None and missing_entry != Nans.NOT_MISSING.value:
-        return None
-      elif attr_quantity is None and missing_entry == Nans.NOT_MISSING.value:
-        return None
-      return missing_entry
-    else:
-      if attr_quantity is None:
-        return Nans.OTHER.value
+    logger = get_structured_logger('load_csv') if logger is None else logger
+    missing_entry = getattr(row, "missing_" + attr_name, None)
+
+    try:
+      missing_entry = CsvImporter.floaty_int(missing_entry) # convert from string to float to int
+    except (ValueError, TypeError):
+      missing_entry = None
+
+    if missing_entry is None and attr_quantity is not None:
       return Nans.NOT_MISSING.value
+    if missing_entry is None and attr_quantity is None:
+      return Nans.OTHER.value
+
+    if missing_entry != Nans.NOT_MISSING.value and attr_quantity is not None:
+      logger.warning(event = f"missing_{attr_name} column contradicting {attr_name} presence.", detail = (str(row)), file = filepath)
+      return Nans.NOT_MISSING.value
+    if missing_entry == Nans.NOT_MISSING.value and attr_quantity is None:
+      logger.warning(event = f"missing_{attr_name} column contradicting {attr_name} presence.", detail = (str(row)), file = filepath)
+      return Nans.OTHER.value
+
+    return missing_entry
 
   @staticmethod
-  def extract_and_check_row(row, geo_type):
+  def extract_and_check_row(row, geo_type, filepath=None):
     """Extract and return `RowValues` from a CSV row, with sanity checks.
 
     Also returns the name of the field which failed sanity check, or None.
@@ -300,31 +312,23 @@ def extract_and_check_row(row, geo_type):
       return (None, 'geo_type')
 
     # Validate row values
-    value = CsvImporter.validate_quantity(row, "val")
-    # val was a string or another dtype
+    value = CsvImporter.validate_quantity(row, "value")
+    # value was a string or another dtype
     if value == "Error":
-      return (None, 'val')
-    stderr = CsvImporter.validate_quantity(row, "se")
-    # Case 1: stderr was a string or another dtype
-    # Case 2: stderr is negative
+      return (None, 'value')
+    stderr = CsvImporter.validate_quantity(row, "stderr")
+    # stderr is a string, another dtype, or negative
     if stderr == "Error" or (stderr is not None and stderr < 0):
-      return (None, 'se')
+      return (None, 'stderr')
     sample_size = CsvImporter.validate_quantity(row, "sample_size")
-    # Case 1: sample_size was a string or another dtype
-    # Case 2: sample_size was negative
+    # sample_size is a string, another dtype, or negative
     if sample_size == "Error" or (sample_size is not None and sample_size < 0):
       return (None, 'sample_size')
 
     # Validate and write missingness codes
-    missing_value = CsvImporter.validate_missing_code(row, value, "val")
-    if missing_value is None:
-      return (None, 'missing_val')
-    missing_stderr = CsvImporter.validate_missing_code(row, stderr, "se")
-    if missing_stderr is None:
-      return (None, 'missing_se')
-    missing_sample_size = CsvImporter.validate_missing_code(row, sample_size, "sample_size")
-    if missing_sample_size is None:
-      return (None, 'missing_sample_size')
+    missing_value = CsvImporter.validate_missing_code(row, value, "value", filepath)
+    missing_stderr = CsvImporter.validate_missing_code(row, stderr, "stderr", filepath)
+    missing_sample_size = CsvImporter.validate_missing_code(row, sample_size, "sample_size", filepath)
 
     # return extracted and validated row values
     row_values = CsvImporter.RowValues(
@@ -344,16 +348,22 @@ def load_csv(filepath, geo_type, pandas=pandas):
     including the header.
     """
     logger = get_structured_logger('load_csv')
-    # don't use type inference, just get strings
-    table = pandas.read_csv(filepath, dtype='str')
+
+    try:
+      table = pandas.read_csv(filepath, dtype=CsvImporter.DTYPES)
+    except ValueError as e:
+      logger.warning(event='Failed to open CSV with specified dtypes, switching to str', detail=str(e), file=filepath)
+      table = pandas.read_csv(filepath, dtype='str')
 
     if not CsvImporter.is_header_valid(table.columns):
       logger.warning(event='invalid header', detail=table.columns, file=filepath)
       yield None
       return
 
+    table.rename(columns={"val": "value", "se": "stderr", "missing_val": "missing_value", "missing_se": "missing_stderr"}, inplace=True)
+
     for row in table.itertuples(index=False):
-      row_values, error = CsvImporter.extract_and_check_row(row, geo_type)
+      row_values, error = CsvImporter.extract_and_check_row(row, geo_type, filepath)
       if error:
         logger.warning(event = 'invalid value for row', detail=(str(row), error), file=filepath)
         yield None
diff --git a/tests/acquisition/covidcast/test_csv_importer.py b/tests/acquisition/covidcast/test_csv_importer.py
index b82dec1ce..3e7224d19 100644
--- a/tests/acquisition/covidcast/test_csv_importer.py
+++ b/tests/acquisition/covidcast/test_csv_importer.py
@@ -59,7 +59,7 @@ def test_find_issue_specific_csv_files(self,os_isdir_mock):
       issuedir_match= CsvImporter.PATTERN_ISSUE_DIR.match(path_prefix.lower())
       issue_date_value = int(issuedir_match.group(2))
       self.assertTrue(CsvImporter.is_sane_day(issue_date_value))
-      
+
       found = set(CsvImporter.find_issue_specific_csv_files(path_prefix, glob=mock_glob))
       self.assertTrue(len(found)>0)
 
@@ -159,22 +159,22 @@ def test_extract_and_check_row(self):
     def make_row(
         geo_type='state',
         geo_id='vi',
-        val='1.23',
-        se='4.56',
+        value='1.23',
+        stderr='4.56',
         sample_size='100.5',
-        missing_val=Nans.NOT_MISSING,
-        missing_se=Nans.NOT_MISSING,
-        missing_sample_size=Nans.NOT_MISSING):
+        missing_value=str(float(Nans.NOT_MISSING)),
+        missing_stderr=str(float(Nans.NOT_MISSING)),
+        missing_sample_size=str(float(Nans.NOT_MISSING))):
       row = MagicMock(
           geo_id=geo_id,
-          val=val,
-          se=se,
+          value=value,
+          stderr=stderr,
           sample_size=sample_size,
-          missing_val=missing_val,
-          missing_se=missing_se,
+          missing_value=missing_value,
+          missing_stderr=missing_stderr,
           missing_sample_size=missing_sample_size,
-          spec=["geo_id", "val", "se", "sample_size",
-                "missing_val", "missing_se", "missing_sample_size"])
+          spec=["geo_id", "value", "stderr", "sample_size",
+                "missing_value", "missing_stderr", "missing_sample_size"])
       return geo_type, row
 
     # cases to test each failure mode
@@ -190,22 +190,16 @@ def make_row(
       (make_row(geo_type='nation', geo_id='0000'), 'geo_id'),
       (make_row(geo_type='hhs', geo_id='0'), 'geo_id'),
       (make_row(geo_type='province', geo_id='ab'), 'geo_type'),
-      (make_row(se='-1'), 'se'),
+      (make_row(stderr='-1'), 'stderr'),
       (make_row(geo_type=None), 'geo_type'),
       (make_row(geo_id=None), 'geo_id'),
-      (make_row(val='inf'), 'val'),
-      (make_row(se='inf'), 'se'),
+      (make_row(value='inf'), 'value'),
+      (make_row(stderr='inf'), 'stderr'),
       (make_row(sample_size='inf'), 'sample_size'),
       (make_row(geo_type='hrr', geo_id='hrr001'), 'geo_id'),
-      (make_row(val='val'), 'val'),
-      (make_row(se='se'), 'se'),
+      (make_row(value='value'), 'value'),
+      (make_row(stderr='stderr'), 'stderr'),
       (make_row(sample_size='sample_size'), 'sample_size'),
-      (make_row(missing_val='missing_val'), 'missing_val'),
-      (make_row(missing_se='missing_val'), 'missing_se'),
-      (make_row(missing_sample_size='missing_val'), 'missing_sample_size'),
-      (make_row(val='1.2', missing_val=Nans.OTHER), 'missing_val'),
-      (make_row(se='1.2', missing_se=Nans.OTHER), 'missing_se'),
-      (make_row(sample_size='1.2', missing_sample_size=Nans.OTHER), 'missing_sample_size')
     ]
 
     for ((geo_type, row), field) in failure_cases:
@@ -213,30 +207,21 @@ def make_row(
       self.assertIsNone(values)
       self.assertEqual(error, field)
 
-    # a nominal case without missing values
-    geo_type, row = make_row()
-    values, error = CsvImporter.extract_and_check_row(row, geo_type)
-
-    self.assertIsInstance(values, CsvImporter.RowValues)
-    self.assertEqual(str(values.geo_value), row.geo_id)
-    self.assertEqual(str(values.value), row.val)
-    self.assertEqual(str(values.stderr), row.se)
-    self.assertEqual(str(values.sample_size), row.sample_size)
-    self.assertIsNone(error)
-
-    # a nominal case with missing values
-    geo_type, row = make_row(
-      se='', sample_size='NA',
-      missing_se=Nans.OTHER, missing_sample_size=Nans.OTHER
-    )
-    values, error = CsvImporter.extract_and_check_row(row, geo_type)
-
-    self.assertIsInstance(values, CsvImporter.RowValues)
-    self.assertEqual(str(values.geo_value), row.geo_id)
-    self.assertEqual(str(values.value), row.val)
-    self.assertIsNone(values.stderr)
-    self.assertIsNone(values.sample_size)
-    self.assertIsNone(error)
+    success_cases = [
+      (make_row(), CsvImporter.RowValues('vi', 1.23, 4.56, 100.5, Nans.NOT_MISSING, Nans.NOT_MISSING, Nans.NOT_MISSING)),
+      (make_row(value=None, stderr=np.nan, sample_size='', missing_value=str(float(Nans.DELETED)), missing_stderr=str(float(Nans.DELETED)), missing_sample_size=str(float(Nans.DELETED))), CsvImporter.RowValues('vi', None, None, None, Nans.DELETED, Nans.DELETED, Nans.DELETED)),
+      (make_row(stderr='', sample_size='NA', missing_stderr=str(float(Nans.OTHER)), missing_sample_size=str(float(Nans.OTHER))), CsvImporter.RowValues('vi', 1.23, None, None, Nans.NOT_MISSING, Nans.OTHER, Nans.OTHER)),
+      (make_row(sample_size=None, missing_value='missing_value', missing_stderr=str(float(Nans.OTHER)), missing_sample_size=str(float(Nans.NOT_MISSING))), CsvImporter.RowValues('vi', 1.23, 4.56, None, Nans.NOT_MISSING, Nans.NOT_MISSING, Nans.OTHER)),
+    ]
+
+    for ((geo_type, row), field) in success_cases:
+      values, error = CsvImporter.extract_and_check_row(row, geo_type)
+      self.assertIsNone(error)
+      self.assertIsInstance(values, CsvImporter.RowValues)
+      self.assertEqual(values.geo_value, field.geo_value)
+      self.assertEqual(values.value, field.value)
+      self.assertEqual(values.stderr, field.stderr)
+      self.assertEqual(values.sample_size, field.sample_size)
 
   def test_load_csv_with_invalid_header(self):
     """Bail loading a CSV when the header is invalid."""
@@ -291,16 +276,14 @@ def test_load_csv_with_valid_header(self):
 
     self.assertIsNone(rows[3])
 
-    # now with missing values! the last missing_sample_size
-    # contains an error code while data is available, which
-    # should give an error
+    # now with missing values!
     data = {
       'geo_id': ['ca', 'tx', 'fl', 'ak'],
       'val': [np.nan, '1.2', '1.3', '1.4'],
       'se': ['2.1', "na", '2.3', '2.4'],
       'sample_size': ['301', '302', None, '304'],
-      'missing_val': [Nans.NOT_APPLICABLE] + [Nans.NOT_MISSING] * 3,
-      'missing_se': [Nans.NOT_MISSING, Nans.REGION_EXCEPTION, Nans.NOT_MISSING, Nans.NOT_MISSING],
+      'missing_value': [Nans.NOT_APPLICABLE] + [Nans.NOT_MISSING] * 3,
+      'missing_stderr': [Nans.NOT_MISSING, Nans.REGION_EXCEPTION, Nans.NOT_MISSING, Nans.NOT_MISSING],
       'missing_sample_size': [Nans.NOT_MISSING] * 2 + [Nans.REGION_EXCEPTION] * 2
     }
     mock_pandas = MagicMock()
@@ -338,4 +321,10 @@ def test_load_csv_with_valid_header(self):
     self.assertEqual(rows[2].missing_stderr, Nans.NOT_MISSING)
     self.assertEqual(rows[2].missing_sample_size, Nans.REGION_EXCEPTION)
 
-    self.assertIsNone(rows[3])
+    self.assertEqual(rows[3].geo_value, 'ak')
+    self.assertEqual(rows[3].value, 1.4)
+    self.assertEqual(rows[3].stderr, 2.4)
+    self.assertEqual(rows[3].sample_size, 304)
+    self.assertEqual(rows[3].missing_value, Nans.NOT_MISSING)
+    self.assertEqual(rows[3].missing_stderr, Nans.NOT_MISSING)
+    self.assertEqual(rows[3].missing_sample_size, Nans.NOT_MISSING)