def test_write_changes_to_memory(self): # make a mock list of proposed changes STORAGE.PROPOSED_CHANGES_PATH = \ "storage_manager_test_files/mock_changes_storage_file2" p = Planet.Planet("a") p.lastupdate = "16/11/20" p2 = Planet.Planet("b") p2.lastupdate = "16/11/20" c1 = Change.Addition("origin str", p) c2 = Change.Modification("Origin str", p, p2, "field", 10, 15) changes_list = [c1, c2] # write the list to memory STORAGE.write_changes_to_memory(changes_list) # retrieve the list and make sure that nothing have been changed retrieved = STORAGE.read_changes_from_memory() self.assertEquals(len(retrieved), 2) self.assertEquals(retrieved[0].__class__.__name__, "Addition") self.assertEquals(retrieved[0].origin, "origin str") self.assertEquals(retrieved[0].get_object_name(), p.name) self.assertEquals(retrieved[1].__class__.__name__, "Modification") self.assertEquals(retrieved[1].origin, "Origin str") self.assertEquals(retrieved[1].get_object_name(), p.name) self.assertEquals(retrieved[1].field_modified, "field") self.assertEquals(retrieved[1].value_in_origin_catalogue, 10) self.assertEquals(retrieved[1].value_in_OEC, 15)
def testInit(self): planet1 = Planet("testPlanet") self.assertEquals("testPlanet", planet1.getName()) self.assertEquals(None, planet1.starObject) self.assertEquals(dict(), planet1.starObjectNamesToStar) self.assertEquals(dict(), planet1.errors) self.assertEquals([], planet1.otherNamesPlanet) self.assertEquals(dict(), planet1.data) self.assertEquals("", planet1.nameStar) self.assertEquals("00/00/00", planet1.lastupdate)
def test_config_set_get_object(self): STORAGE.CONFIG_PATH = "storage_manager_test_files/mock_config_file" STORAGE.clean_config_file() p = Planet.Planet("a") p.lastupdate = "16/11/20" test_object = Change.Addition("origin", p) STORAGE.config_set("key", test_object) retrieved = STORAGE.config_get("key") self.assertEqual(retrieved.__class__.__name__, "Addition") self.assertEqual(retrieved.origin, "origin")
def __init__(self, *args, **kwargs): super(testing_merge, self).__init__(*args, **kwargs) self.planet1 = Planet.Planet("A") self.planet2 = Planet.Planet("B") self.planet3 = Planet.Planet("C") self.planet4 = Planet.Planet("RR") self.planet5 = Planet.Planet("UU") self.planet6 = Planet.Planet("dddddd") self.p = Planet.Planet("Z")
def setUp(self): self.planet1 = Planet("planet1") self.planet1.addVal("mass", 10) self.planet2 = Planet("planet2") self.planet2.addVal("mass", 12) self.planet2.addVal("temperature", 145) self.Star1 = Star("star1") self.Star1.addVal("mass", 100) self.Star2 = Star("star2") self.Star2.addVal("mass", 112) self.Star3 = Star("star3") self.system1 = System("sys1") self.planet3 = Planet("planet3") self.planet3.addVal("temperature", 145) self.planet4 = Planet("planet4") self.Star1.planetObjects = [self.planet1, self.planet3] self.Star2.planetObjects = [self.planet1, self.planet3, self.planet4] self.Star3.planetObjects = [self.planet1, self.planet3] self.EStar1 = Star("empty1") self.EStar2 = Star("empty2")
def test_sort_order(self): self.p1 = Planet.Planet("a") self.p2 = Planet.Planet("b") self.p3 = Planet.Planet("c") self.p4 = Planet.Planet("d") self.p5 = Planet.Planet("e") self.p6 = Planet.Planet("f") a = Modification("aaa", self.p1, self.p, "fieldname", 10, 11) b = Addition("source", self.p2) c = Addition("source", self.p3) d = Modification("source", self.p4, self.p, "field", 5, 6) e = Modification("source", self.p5, self.p, "field", 1, 2) f = Modification("source", self.p6, self.p, "field", 3, 4) L = [b, a, d, c, f, e] result = merge_sort_changes(L) self.assertTrue(isinstance(result, list)) self.assertEqual(len(result), 6) self.assertEqual(result[0].get_object_name(), a.get_object_name()) self.assertEqual(result[1].get_object_name(), b.get_object_name()) self.assertEqual(result[2].get_object_name(), c.get_object_name()) self.assertEqual(result[3].get_object_name(), d.get_object_name()) self.assertEqual(result[4].get_object_name(), e.get_object_name()) self.assertEqual(result[5].get_object_name(), f.get_object_name())
class TestComparator(unittest.TestCase): def setUp(self): self.planet1 = Planet("planet1") self.planet1.addVal("mass", 10) self.planet2 = Planet("planet2") self.planet2.addVal("mass", 12) self.planet2.addVal("temperature", 145) self.Star1 = Star("star1") self.Star1.addVal("mass", 100) self.Star2 = Star("star2") self.Star2.addVal("mass", 112) self.Star3 = Star("star3") self.system1 = System("sys1") self.planet3 = Planet("planet3") self.planet3.addVal("temperature", 145) self.planet4 = Planet("planet4") self.Star1.planetObjects = [self.planet1, self.planet3] self.Star2.planetObjects = [self.planet1, self.planet3, self.planet4] self.Star3.planetObjects = [self.planet1, self.planet3] self.EStar1 = Star("empty1") self.EStar2 = Star("empty2") def testCreateComparatorWithNonPlanetaryObjects(self): try: rip = Comparator("egg", 1, "eu") except ObjectTypeMismatchException: self.assertTrue(True) def testCreateComparatorWithDifferentPlanetaryObjects(self): try: rip = Comparator(self.planet1, self.Star1, "eu") except ObjectTypeMismatchException: self.assertTrue(True) def testSQLjoin(self): comparator = Comparator(self.planet2, self.planet1, "eu") result = comparator.sqlJoin(True) a = result["data"] b = ["mass", "temperature"] self.assertTrue( len(a) == len(b) and all(a.count(i) == b.count(i) for i in a)) c = result["left"] d = [12, 145] self.assertTrue( len(c) == len(d) and all(c.count(i) == d.count(i) for i in c)) e = result["right"] f = [10, "N/A"] self.assertTrue( len(e) == len(f) and all(e.count(i) == f.count(i) for i in e)) def testInnerJoinDiffFieldMatch(self): comparator = Comparator(self.Star1, self.Star2, "eu") inner = comparator.innerJoinDiff() self.assertEqual(inner, {'mass': (100, 112)}) def testInnerJoinDiffFieldDiff(self): comparator = Comparator(self.planet1, self.planet3, "eu") inner = comparator.innerJoinDiff() self.assertEqual(inner, {}) def testStarCompareWithNonStarObjects(self): comparator = Comparator(self.planet1, self.planet2, "eu") try: comparator.starCompare() except ObjectTypeIncompatibleException: self.assertTrue(True) def testStarCompareEmptyStarsStarC(self): comparator = Comparator(self.EStar1, self.EStar2, "eu") result = comparator.starCompare() self.assertEqual(result["starC"], {}) def testStarCompareEmptyStarsStarN(self): comparator = Comparator(self.EStar1, self.EStar2, "eu") result = comparator.starCompare() self.assertEqual(result["starN"]["data"], []) self.assertEqual(result["starN"]["left"], []) self.assertEqual(result["starN"]["right"], []) def testStarCompareEmptyStarsPlanetN(self): comparator = Comparator(self.EStar1, self.EStar2, "eu") result = comparator.starCompare() self.assertEqual(result["planetN"]["left"], []) self.assertEqual(result["planetN"]["right"], []) def testStarCompareEmptyStarsPlanetDN(self): comparator = Comparator(self.EStar1, self.EStar2, "eu") result = comparator.starCompare() self.assertEqual(result["planetDN"], {}) def testStarCompareEmptyStarsPlanetDC(self): comparator = Comparator(self.EStar1, self.EStar2, "eu") result = comparator.starCompare() self.assertEqual(result["planetDC"], {}) def testStarCompareEmptyStarsPlanetA(self): comparator = Comparator(self.EStar1, self.EStar2, "eu") result = comparator.starCompare() self.assertEqual(result["planetA"], {}) def testStarCompareStarWithOneFieldStarC(self): comparator = Comparator(self.Star1, self.Star2, "eu") result = comparator.starCompare() starC = result["starC"] answer = {"mass": (100.0, 112.0)} self.assertEqual(starC, answer) def testStarCompareStarWithOneFieldStarN(self): comparator = Comparator(self.Star1, self.Star2, "eu") result = comparator.starCompare() starN = result["starN"] answer = {"data": ["mass"], "left": [100.0], "right": [112.0]} self.assertEqual(starN, answer) def testStarCompareStarWithOneFieldStarN2(self): comparator = Comparator(self.Star1, self.Star2, "eu") result = comparator.starCompare() planetN = result["planetN"] answer = {"left": [], "right": [self.planet4]} self.assertEqual(planetN, answer) def testStarCompareStarWithOneFieldPlanetDN(self): comparator = Comparator(self.Star1, self.Star2, "eu") result = comparator.starCompare() planetDN = result["planetDN"] answer = {} self.assertEqual(planetDN, answer) def testStarCompareStarWithOneFieldPlanetDC(self): comparator = Comparator(self.Star1, self.Star2, "eu") result = comparator.starCompare() planetDC = result["planetDC"] answer = {} self.assertEqual(planetDC, answer) def testStarCompareStarWithOneFieldPlanetA(self): comparator = Comparator(self.Star1, self.Star2, "eu") result = comparator.starCompare() planetA = result["planetA"] answer = {"planet1": self.planet1, "planet3": self.planet3} self.assertEqual(planetA, answer) def testproposedChangeStarCompare(self): comparator = Comparator(self.Star3, self.Star2, "eu") result = comparator.proposedChangeStarCompare() resultNames = [ result[0].get_object_name(), result[1].get_object_name() ] answer = [self.planet1.name, self.planet3.name] print(resultNames, answer) self.assertTrue( len(resultNames) == len(answer) and all( resultNames.count(i) == answer.count(i) for i in resultNames))
def buildSystemFromXML(path="../storage/OEC_XML.gz"): ''' () -> ([System], [Star], [Planet], {systemName: System}, {starName: Star}, {planetName: Planet}) Parse the xml from the big xml document that contains every system into a tuple of system objects, star objects, and planet objects. Each Planetary Object dictionary contains the fields that are present from the xml it was parsed from, no more, no less. The system have a list of references to its stars, the stars have a list of references to its planets, and the planets have a reference to the star and system it is in, and stars have a refernece to the system it is in REQ: Valid internet connection ''' # initialize empty lists that will be returned at the end of all # planetary objects oec = readXML(path) allSystems = [] allStars = [] allPlanets = [] allSystemsDict = dict() allStarsDict = dict() allPlanetsDict = dict() # loop through each system in the xml for systemXML in oec.findall(".//system"): # loop through teach tag in the system that is name i = 0 for child in systemXML.findall(".//name"): cleanNameSystem = ''.join( ch for ch in child.text if ch.isalnum()).lower() if child.tag == "name": # if it is the first name, create a System object with that # main name if i == 0: systemName = child.text system = System(systemName) allSystemsDict[child.text] = system system.otherNamesSystem.append(cleanNameSystem) # if there are more names, create / add them to other names list elif i == 1: system.otherNamesSystem.append(child.text) system.otherNamesSystem.append(cleanNameSystem) allSystemsDict[child.text] = system else: system.otherNamesSystem.append(child.text) system.otherNamesSystem.append(cleanNameSystem) allSystemsDict[child.text] = system i += 1 else: system.otherNamesSystem.append(child.text) system.otherNamesSystem.append(cleanNameSystem) allSystemsDict[child.text] = system # build the system data dictionary mapping the tag name to the tag value # in the system for child in systemXML: if (child.tag.lower() != "star") and (child.tag.lower() != "name"): system.addVal(child.tag, child.text) # build a list of stars that are in the system stars = [] # loop through each star in the system localStarsDict = dict() for starXML in systemXML.findall(".//star"): ii = 0 # loop through teach tag in the star that is name for child in starXML.findall(".//name"): cleanNameStar = ''.join( ch for ch in child.text if ch.isalnum()).lower() if child.tag == "name": # if it is the first name, create a Star object with that # main name if ii == 0: star = Star(child.text) allStarsDict[child.text] = star localStarsDict[child.text] = star localStarsDict[cleanNameStar] = star star.otherNamesStar.append(cleanNameStar) # if there are more names, create / add them to other names # list elif ii == 1: star.otherNamesStar.append(child.text) star.otherNamesStar.append(cleanNameStar) allStarsDict[child.text] = star localStarsDict[child.text] = star localStarsDict[cleanNameStar] = star else: star.otherNamesStar.append(child.text) star.otherNamesStar.append(cleanNameStar) allStarsDict[child.text] = star localStarsDict[child.text] = star localStarsDict[cleanNameStar] = star ii += 1 else: star.otherNamesStar.append(child.text) star.otherNamesStar.append(cleanNameStar) allStarsDict[child.text] = star localStarsDict[child.text] = star localStarsDict[cleanNameStar] = star # build the star data dictionary mapping the tag name to the tag # value in the system for child in starXML: if (child.tag.lower() != "planet") and ( child.tag.lower() != "name"): star.addVal(child.tag, child.text) for attribute in child.attrib: if "error" in attribute or "limit" in attribute: star.errors[child.tag + attribute] = child.attrib[ attribute] # build a list of planets that are in the star planets = [] # loop through each planet in the star localPlanetsDict = dict() for planetXML in starXML.findall(".//planet"): iii = 0 # loop through teach tag in the planet that is name for child in planetXML.findall(".//name"): cleanNamePlanets = ''.join( ch for ch in child.text if ch.isalnum()).lower() if child.tag == "name": # if it is the first name, create a Planet object with # that main name if iii == 0: planet = Planet(child.text) allPlanetsDict[child.text] = planet localPlanetsDict[child.text] = planet localPlanetsDict[cleanNamePlanets] = planet planet.otherNamesPlanet.append(cleanNamePlanets) # if there are more names, create / add them to other # names list elif iii == 1: planet.otherNamesPlanet.append(child.text) planet.otherNamesPlanet.append(cleanNamePlanets) allPlanetsDict[child.text] = planet localPlanetsDict[child.text] = planet localPlanetsDict[cleanNamePlanets] = planet else: planet.otherNamesPlanet.append(child.text) planet.otherNamesPlanet.append(cleanNamePlanets) allPlanetsDict[child.text] = planet localPlanetsDict[child.text] = planet localPlanetsDict[cleanNamePlanets] = planet iii += 1 else: planet.otherNamesPlanet.append(child.text) planet.otherNamesPlanet.append(cleanNamePlanets) allPlanetsDict[child.text] = planet localPlanetsDict[child.text] = planet localPlanetsDict[cleanNamePlanets] = planet # build the planet data dictionary mapping the tag name to the # tag value in the system for child in planetXML: if (child.tag.lower() != "name") and ( child.tag.lower() != "lastupdate"): planet.addVal(child.tag, child.text) for attribute in child.attrib: if "error" in attribute or "limit" in attribute: planet.errors[child.tag + attribute] = \ child.attrib[ attribute] # add the star name that the planet is in planet.nameStar = star.name planet.starObjectNamesToStar[star.name] = star planet.starObjectNamesToStar[''.join( ch for ch in star.name if ch.isalnum()).lower()] = star starData = star.getData() # and others if there are any planet.otherNamesStar = star.otherNamesStar for starObject in star.otherNamesStar: planet.starObjectNamesToStar[ starObject] = star planet.starObjectNamesToStar[ ''.join(ch for ch in starObject if ch.isalnum()).lower()] = star # add this planet to the list of planets in the star planets.append(planet) # and all planets list allPlanets.append(planet) # add the star reference in the planet planet.starObject = star # add the list of planets in the star to the star star.planetObjects = planets # add the name of the system that the star is in star.nameSystem = system.name star.systemObjectNamesToSystem[star.nameSystem] = system star.systemObjectNamesToSystem[ ''.join(ch for ch in star.nameSystem if ch.isalnum()).lower()] = system star.nameToPlanet = localPlanetsDict systemData = system.getData() # and others if there are any star.otherNamesSystem = system.otherNamesSystem for systemObject in system.otherNamesSystem: star.systemObjectNamesToSystem[ systemObject] = system star.systemObjectNamesToSystem[ ''.join(ch for ch in systemObject if ch.isalnum()).lower()] = system # add the stars to the list of stars in the system stars.append(star) # and all stars list allStars.append(star) # add the system reference in the star star.systemObject = system # add the list of stars in the system to the system system.starObjects = stars system.nameToStar = localStarsDict # add the system to the list of all systems list allSystems.append(system) return (allSystems, allStars, allPlanets, allSystemsDict, allStarsDict, allPlanetsDict)
def __init__(self, *args, **kwargs): super(testing_constructors, self).__init__(*args, **kwargs) self.planet = Planet.Planet("A") self.star = Star.Star("B") self.system = System.System("C") self.p = Planet.Planet("Z")