def test_it_returns_percentage_increase_for_each_country(self):
country_summary = CountrySummary()
country_summary.total_confirmed = 110
country_summary.new_confirmed = 10
repo = TupleCovidRepository((country_summary,))
analyzer = RatioAnalyzer(repo)
self.assertEqual((0.1,), tuple(analyzer.get_new_confirmed_ratio()))
def load(self):
"""
loads data from the repository
Returns
-------
list of CountrySummary
"""
con = sqlite3.connect(self.filename)
cursor = con.cursor()
query = f"SELECT * from {self.table_name}"
country_summaries = []
for row in cursor.execute(query):
country_summary = CountrySummary()
country_summary.name = row[0]
country_summary.new_confirmed = int(row[1])
country_summary.total_confirmed = int(row[2])
country_summary.new_deaths = int(row[3])
country_summary.total_deaths = int(row[4])
country_summary.new_recovered = int(row[5])
country_summary.total_recovered = int(row[6])
country_summaries += (country_summary, )
return country_summaries
def test_it_can_return_filter_by_new_confirmed_threshold_reversed(self):
first_country_summary = CountrySummary()
first_country_summary.new_confirmed = 10
first_country_summary.total_recovered = 1
second_country_summary = CountrySummary()
second_country_summary.new_confirmed = 9
second_country_summary.total_recovered = 2
country_summaries = (first_country_summary, second_country_summary)
filter_new_confirmed = FilterByThreshold(field="new_confirmed",
threshold=9,
reversed=True)
filtered_summaries = filter_new_confirmed.apply_to(country_summaries)
self.assertEqual(1, len(filtered_summaries))
self.assertIs(second_country_summary, filtered_summaries[0])
filter_total_recovered = FilterByThreshold(field="total_recovered",
threshold=1,
reversed=True)
filtered_summaries = filter_total_recovered.apply_to(country_summaries)
self.assertEqual(1, len(filtered_summaries))
self.assertIs(first_country_summary, filtered_summaries[0])
def test_it_can_be_converted_to_flat_dict(self):
summary = CountrySummary()
summary.name = "test"
summary.new_deaths = 100
summary.total_deaths = 1000
summary.new_confirmed = 200
summary.total_confirmed = 2000
summary.new_recovered = 300
summary.total_recovered = 3000
self.assertEqual(
{
"name": "test",
"new_deaths": 100,
"total_deaths": 1000,
"new_confirmed": 200,
"total_confirmed": 2000,
"new_recovered": 300,
"total_recovered": 3000,
},
summary.to_dict(),
)
def test_it_saves_to_db(self):
first_country = CountrySummary()
first_country.name = "aa"
first_country.new_confirmed = 100
second_country = CountrySummary()
second_country.name = "bb"
second_country.new_deaths = 150
country_summaries = [first_country, second_country]
repository = SqliteCovidRepository(filename=self.dbfilename)
repository.save(country_summaries)
loaded_data = repository.load()
self.assertEqual(loaded_data, country_summaries)
def test_it_creates_db_if_not_exists(self):
first_country = CountrySummary()
first_country.name = "aa"
first_country.new_confirmed = 100
second_country = CountrySummary()
second_country.name = "bb"
second_country.new_deaths = 150
country_summaries = [first_country, second_country]
repository = SqliteCovidRepository(filename=self.dbfilename)
repository.save(country_summaries)
self.assertTrue(
os.path.exists(self.dbfilename)
and os.path.isfile(self.dbfilename))
def test_it_can_call_class_by_passing_which_statistics_should_be_generated(self):
country_summary = CountrySummary()
country_summary.name = "Italy"
country_summary.total_confirmed = 110
country_summary.new_confirmed = 10
country_summary.total_recovered = 210
country_summary.new_recovered = 10
country_summary.total_deaths = 410
country_summary.new_deaths = 10
repo = TupleCovidRepository((country_summary,))
analyzer = RatioAnalyzer(repo)
self.assertEqual(
{
"Italy": {
"new_confirmed_ratio": 0.1,
"new_recovered_ratio": 0.05,
"new_deaths_ratio": 0.025,
}
},
analyzer(
new_confirmed_ratio=True,
new_recovered_ratio=True,
new_deaths_ratio=True,
),
)
self.assertEqual(
{"Italy": {"new_recovered_ratio": 0.05, "new_deaths_ratio": 0.025,}},
analyzer(
new_confirmed_ratio=False,
new_recovered_ratio=True,
new_deaths_ratio=True,
),
)
self.assertEqual(
{"Italy": {"new_recovered_ratio": 0.05,}},
analyzer(new_recovered_ratio=True, new_deaths_ratio=False),
)
def test_it_saves_to_file(self):
filename = "file.csv"
first_country = CountrySummary()
first_country.name = "aa"
first_country.new_confirmed = 100
second_country = CountrySummary()
second_country.name = "bb"
second_country.new_deaths = 150
country_summaries = [first_country, second_country]
repository = StorageCovidRepository(filename=filename)
repository.save(country_summaries)
f = open(filename, "r")
content = f.read()
f.close()
self.assertEqual("aa|100|0|0|0|0|0\nbb|0|0|150|0|0|0", content)
def load(self):
"""
loads data from the repository
Returns
-------
list of CountrySummary
"""
dummy_country_summaries = ()
for i in range(0, 100):
country_summary = CountrySummary()
country_summary.name = self.__randomString(20)
country_summary.new_confirmed = random.randint(1, 1000)
country_summary.new_deaths = random.randint(1, 1000)
country_summary.total_deaths = random.randint(1, 10000) + country_summary.new_deaths
country_summary.total_confirmed = random.randint(1, 10000) + country_summary.new_confirmed
country_summary.new_recovered = random.randint(1, 1000)
country_summary.total_recovered = random.randint(1, 10000) + country_summary.new_recovered
dummy_country_summaries += (country_summary,)
return dummy_country_summaries
def test_it_can_return_filter_by_name_portion(self):
first_country_summary = CountrySummary()
first_country_summary.name = "Italy"
second_country_summary = CountrySummary()
second_country_summary.name = "U.S.A."
country_summaries = (first_country_summary, second_country_summary)
filter = FilterByName(country_name="Italy")
filtered_summaries = filter.apply_to(country_summaries)
self.assertEqual(1, len(filtered_summaries))
self.assertIs(first_country_summary, filtered_summaries[0])
def test_two_country_summaries_can_be_compared_for_equality(self):
summary1 = CountrySummary()
summary1.name = "test"
summary1.new_deaths = 100
summary1.total_deaths = 1000
summary1.new_confirmed = 200
summary1.total_confirmed = 2000
summary1.new_recovered = 300
summary1.total_recovered = 3000
summary2 = CountrySummary()
summary2.name = "test"
summary2.new_deaths = 100
summary2.total_deaths = 1000
summary2.new_confirmed = 200
summary2.total_confirmed = 2000
summary2.new_recovered = 300
summary2.total_recovered = 3000
self.assertEqual(summary1, summary2)