class DimensionTestCase(unittest.TestCase):
def setUp(self):
self.levels = [
Level("year", attributes=create_list_of(Attribute, ["year"])),
Level("month", attributes=create_list_of(Attribute, ["month", "month_name",
"month_sname"])),
Level("day", attributes=create_list_of(Attribute, ["day"])),
Level("week", attributes=create_list_of(Attribute, ["week"]))
]
self.level_names = [level.name for level in self.levels]
self.dimension = Dimension("date", levels=self.levels)
levels = [self.levels[0], self.levels[1], self.levels[2]]
self.hierarchy = Hierarchy("default", levels)
def test_create(self):
"""Dimension from a dictionary"""
dim = Dimension.from_metadata("year")
self.assertIsInstance(dim, Dimension)
self.assertEqual("year", dim.name)
self.assertEqual(["year.year"], [str(a) for a in dim.attributes])
# Test default: explicit level attributes
desc = {"name": "date", "levels": ["year"]}
dim = Dimension.from_metadata(desc)
self.assertTrue(dim.is_flat)
self.assertFalse(dim.has_details)
self.assertIsInstance(dim, Dimension)
self.assertEqual("date", dim.name)
# Dimension string is a reference and is equal to dimension name if
# dimension is flat
self.assertEqual(["date.year"], [str(a) for a in dim.attributes])
desc = {"name": "date", "levels": ["year", "month", "day"]}
dim = Dimension.from_metadata(desc)
self.assertIsInstance(dim, Dimension)
self.assertEqual("date", dim.name)
refs = [str(a) for a in dim.attributes]
self.assertEqual(["date.year", "date.month", "date.day"], refs)
self.assertFalse(dim.is_flat)
self.assertFalse(dim.has_details)
self.assertEqual(3, len(dim.levels))
for level in dim.levels:
self.assertIsInstance(level, Level)
self.assertEqual(1, len(dim.hierarchies))
self.assertEqual(3, len(dim.hierarchy()))
# Test default: implicit single level attributes
desc = {"name": "product", "attributes": ["code", "name"]}
dim = Dimension.from_metadata(desc)
refs = [str(a) for a in dim.attributes]
self.assertEqual(["product.code", "product.name"], refs)
self.assertEqual(1, len(dim.levels))
self.assertEqual(1, len(dim.hierarchies))
def test_flat_dimension(self):
"""Flat dimension and 'has details' flags"""
dim = Dimension.from_metadata("foo")
self.assertTrue(dim.is_flat)
self.assertFalse(dim.has_details)
self.assertEqual(1, len(dim.levels))
level = dim.level("foo")
self.assertIsInstance(level, Level)
self.assertEqual("foo", level.name)
self.assertEqual(1, len(level.attributes))
self.assertEqual("foo.foo", str(level.key))
attr = level.attributes[0]
self.assertIsInstance(attr, Attribute)
self.assertEqual("foo", attr.name)
def test_comparisons(self):
"""Comparison of dimension instances"""
dim1 = Dimension.from_metadata(DIM_DATE_DESC)
dim2 = Dimension.from_metadata(DIM_DATE_DESC)
self.assertListEqual(dim1.levels, dim2.levels)
self.assertListEqual(dim1.hierarchies, dim2.hierarchies)
self.assertEqual(dim1, dim2)
def test_to_dict(self):
desc = self.dimension.to_dict()
dim = Dimension.from_metadata(desc)
self.assertEqual(self.dimension.hierarchies, dim.hierarchies)
self.assertEqual(self.dimension.levels, dim.levels)
self.assertEqual(self.dimension, dim)
def test_template(self):
dims = {"date": self.dimension}
desc = {"template": "date", "name": "date"}
dim = Dimension.from_metadata(desc, dims)
self.assertEqual(self.dimension, dim)
hier = dim.hierarchy()
self.assertEqual(4, len(hier.levels))
desc["hierarchy"] = ["year", "month"]
dim = Dimension.from_metadata(desc, dims)
self.assertEqual(1, len(dim.hierarchies))
hier = dim.hierarchy()
self.assertEqual(2, len(hier.levels))
template = self.dimension.to_dict()
template["hierarchies"] = [
{"name": "ym", "levels": ["year", "month"]},
{"name": "ymd", "levels": ["year", "month", "day"]}
]
template["default_hierarchy_name"] = "ym"
template = Dimension.from_metadata(template)
dims = {"date": template}
desc = {"template": "date", "name":"another_date"}
dim = Dimension.from_metadata(desc, dims)
self.assertEqual(2, len(dim.hierarchies))
self.assertEqual(["ym", "ymd"],
[hier.name for hier in dim.hierarchies])
def test_template_hierarchies(self):
md = {
"name": "time",
"levels": ["year", "month", "day", "hour"],
"hierarchies": [
{"name": "full", "levels": ["year", "month", "day", "hour"]},
{"name": "ymd", "levels": ["year", "month", "day"]},
{"name": "ym", "levels": ["year", "month"]},
{"name": "y", "levels": ["year"]},
]
}
dim_time = Dimension.from_metadata(md)
templates = {"time": dim_time}
md = {
"name": "date",
"template": "time",
"hierarchies": [
"ymd", "ym", "y"
]
}
dim_date = Dimension.from_metadata(md, templates)
self.assertEqual(dim_date.name, "date")
self.assertEqual(len(dim_date.hierarchies), 3)
names = [h.name for h in dim_date.hierarchies]
self.assertEqual(["ymd", "ym", "y"], names)
def test_template_info(self):
md = {
"name": "template",
"levels": [
{ "name": "one", "info": {"units":"$", "format": "foo"}}
]
}
tempdim = Dimension.from_metadata(md)
md = {
"name": "dim",
"levels": [
{ "name": "one", "info": {"units":"USD"}}
],
"template": "template"
}
templates = {"template": tempdim}
dim = Dimension.from_metadata(md, templates)
level = dim.level("one")
self.assertIn("units", level.info)
self.assertIn("format", level.info)
self.assertEqual(level.info["units"], "USD")
self.assertEqual(level.info["format"], "foo")
