def test_use_different_scheme(self):
lines = [
"%s%s %s" % (
MafHeader.HeaderLineStartSymbol,
MafHeader.VersionKey,
GdcV1_0_0_ProtectedScheme.version(),
),
"%s%s %s" % (
MafHeader.HeaderLineStartSymbol,
MafHeader.AnnotationSpecKey,
GdcV1_0_0_ProtectedScheme.annotation_spec(),
),
"\t".join(GdcV1_0_0_BasicScheme().column_names()),
]
reader = MafReader(lines=lines, scheme=None)
self.assertIsNone(next(reader, None))
self.assertEqual(len(reader.validation_errors), 1)
self.assertListEqual(
[e.tpe for e in reader.validation_errors],
[MafValidationErrorType.SCHEME_MISMATCHING_NUMBER_OF_COLUMN_NAMES],
)
self.assertEqual(reader.header().scheme().version(),
GdcV1_0_0_BasicScheme.version())
self.assertEqual(reader.scheme().version(),
GdcV1_0_0_ProtectedScheme().version())
self.assertEqual(
reader.scheme().annotation_spec(),
GdcV1_0_0_ProtectedScheme.annotation_spec(),
)
self.assertEqual(
reader.header().scheme().annotation_spec(),
GdcV1_0_0_ProtectedScheme.annotation_spec(),
)
def test_use_scheme_from_header_basic(self):
version = "%s%s %s" % (
MafHeader.HeaderLineStartSymbol,
MafHeader.VersionKey,
GdcV1_0_0_BasicScheme.version(),
)
lines = [version, "\t".join(GdcV1_0_0_BasicScheme().column_names())]
reader = MafReader(lines=lines, scheme=None)
self.assertIsNone(next(reader, None))
self.assertEqual(len(reader.validation_errors), 0)
self.assertEqual(reader.header().scheme().version(),
GdcV1_0_0_BasicScheme().version())
def test_columns(self):
self.assertEqual(len(GdcV1_0_0_BasicScheme.__column_dict__()), 34)
self.assertEqual(len(GdcV1_0_0_PublicScheme.__column_dict__()), 119)
self.assertEqual(len(GdcV1_0_0_ProtectedScheme.__column_dict__()), 125)
self.assertEqual(
len(TestGdcV1_0_0_Scheme.NoAnnotationSpecScheme.__column_dict__()),
0)
def test_schemes(self):
for scheme in [
GdcV1_0_0_BasicScheme(),
GdcV1_0_0_ProtectedScheme(),
GdcV1_0_0_PublicScheme(),
]:
# TODO: make up a valid string value for each column, and make sure it builds OK
for name in scheme.column_names():
cls = scheme.column_class(name)
column_index = scheme.column_index(name)
cls.build(name=name, value="Gene", column_index=column_index)
break
def test_dict_methods(self):
"""
Checks that the header is well-behaved for a Mapping
"""
version = MafHeaderRecord(MafHeader.VersionKey, TestMafHeader.Version)
record1 = MafHeaderRecord("key1", "value1")
record2 = MafHeaderRecord("key1", "value2")
header = MafHeader()
# Set version
self.assertNotIn(version.key, header)
header[version.key] = version
self.assertIn(version.key, header)
self.assertTrue(len(header) == 1)
self.assertListEqual(list(header.keys()), [MafHeader.VersionKey])
self.assertTrue(header.values(), [TestMafHeader.Version])
self.assertEqual(header.version(), TestMafHeader.Version)
expected_scheme = GdcV1_0_0_BasicScheme()
self.assertEqual(header.scheme().version(), expected_scheme.version())
self.assertEqual(header.scheme().annotation_spec(),
expected_scheme.annotation_spec())
# Set when it is not in the header
self.assertNotIn(record1.key, header)
header[record1.key] = record1
self.assertIn(record1.key, header)
self.assertTrue(len(header) == 2)
self.assertListEqual(list(header.keys()),
[MafHeader.VersionKey, "key1"])
self.assertTrue(header.values(), [TestMafHeader.Version, "value1"])
# Overwrite
self.assertIn(record2.key, header)
header[record2.key] = record2
self.assertIn(record2.key, header)
self.assertTrue(len(header) == 2)
self.assertListEqual(list(header.keys()),
[MafHeader.VersionKey, "key1"])
self.assertTrue(header.values(), [TestMafHeader.Version, "value2"])
# Remove it
del header[record2.key]
self.assertNotIn(record2.key, header)
self.assertTrue(len(header) == 1)
self.assertListEqual(list(header.keys()), [MafHeader.VersionKey])
self.assertTrue(header.values(), [TestMafHeader.Version])
def test_use_default_scheme(self):
lines = [
TestMafReader.AnnotationSpec,
"\t".join(GdcV1_0_0_BasicScheme().column_names()),
]
reader = MafReader(lines=lines, scheme=None)
self.assertIsNone(next(reader, None))
self.assertEqual(len(reader.validation_errors), 2)
self.assertListEqual(
[e.tpe for e in reader.validation_errors],
[
MafValidationErrorType.HEADER_MISSING_VERSION,
MafValidationErrorType.HEADER_UNSUPPORTED_ANNOTATION_SPEC,
],
)
self.assertIsNone(reader.header().scheme())
self.assertEqual(
reader.scheme().version(),
NoRestrictionsScheme(column_names=list()).version(),
)
def test_from_lines_unsupported_annotation(self):
scheme = GdcV1_0_0_BasicScheme()
lines = [
"%s%s %s" % (MafHeader.HeaderLineStartSymbol, MafHeader.VersionKey,
scheme.version()),
"%s%s %s" % (
MafHeader.HeaderLineStartSymbol,
MafHeader.AnnotationSpecKey,
scheme.annotation_spec(),
),
]
header = MafHeader.from_lines(
lines=lines, validation_stringency=ValidationStringency.Silent)
self.assertTrue(len(header.validation_errors) == 1)
self.assertEqual(
header.validation_errors[0].tpe,
MafValidationErrorType.HEADER_UNSUPPORTED_ANNOTATION_SPEC,
)
self.assertIsNotNone(header.annotation())
self.assertIsNotNone(header.scheme())
for line in [
"#%s not_annotation" % MafHeader.AnnotationSpecKey,
"#%s %sx" %
(MafHeader.AnnotationSpecKey, TestMafHeader.AnnotationSpec),
]:
lines = [TestMafHeader.__version_line, line]
header = MafHeader.from_lines(
lines=lines, validation_stringency=ValidationStringency.Silent)
self.assertTrue(len(header.validation_errors) == 1)
self.assertEqual(
header.validation_errors[0].tpe,
MafValidationErrorType.HEADER_UNSUPPORTED_ANNOTATION_SPEC,
)
self.assertIsNotNone(header.annotation())
self.assertIsNone(header.scheme())
def test_different_scheme_in_header(self):
version = "%s%s %s" % (
MafHeader.HeaderLineStartSymbol,
MafHeader.VersionKey,
GdcV1_0_0_BasicScheme.version(),
)
# annotation = "%s%s %s" % (MafHeader.HeaderLineStartSymbol, MafHeader.AnnotationSpecKey, TestMafReader.Scheme.annotation_spec())
lines = [version, "\t".join(TestMafReader.Names)]
# When a scheme is given, we should get a HEADER_MISMATCH_SCHEME error
reader = MafReader(lines=lines, scheme=TestMafReader.Scheme)
self.assertIsNone(next(reader, None))
self.assertListEqual(
[e.tpe for e in reader.validation_errors],
[MafValidationErrorType.HEADER_MISMATCH_SCHEME],
)
# But when no scheme is given, then we should get a SCHEME_MISMATCHING_NUMBER_OF_COLUMN_NAMES error
reader = MafReader(lines=lines, scheme=None)
self.assertIsNone(next(reader, None))
self.assertListEqual(
[e.tpe for e in reader.validation_errors],
[MafValidationErrorType.SCHEME_MISMATCHING_NUMBER_OF_COLUMN_NAMES],
)
def annotation_spec(cls):
return GdcV1_0_0_BasicScheme.annotation_spec()
def version(cls):
return GdcV1_0_0_BasicScheme.version()
def test_is_basic(self):
self.assertTrue(GdcV1_0_0_BasicScheme().is_basic())
self.assertFalse(GdcV1_0_0_PublicScheme().is_basic())
self.assertFalse(GdcV1_0_0_ProtectedScheme().is_basic())
self.assertFalse(
TestGdcV1_0_0_Scheme.NoAnnotationSpecScheme().is_basic())