def test_11_high_blood_pressure3(self):
scatter_method = spy_decorator(matplotlib.axes.Axes.scatter, "scatter")
plot_method = spy_decorator(matplotlib.axes.Axes.plot, "plot")
# with patch("matplotlib.pyplot.scatter", wraps=matplotlib.pyplot.scatter) as pltscatter:
with patch("matplotlib.pyplot.subplots", wraps=matplotlib.pyplot.subplots) as psubplots,\
patch.object(matplotlib.axes.Axes, "plot", new=plot_method),\
patch.object(matplotlib.axes.Axes, "scatter", new=scatter_method):
exec(exercises[0])
exec(exercises[1])
exec(exercises[2])
exec(exercises[3])
exec(exercises[9])
exec(exercises[10])
exec(exercises[11])
myfram = locals()["fram"]
psubplots.assert_called()
self.assertEqual(scatter_method.mock.call_count, 2,
msg="Expected scatter method to be called twice!")
self.assertEqual(plot_method.mock.call_count, 6,
msg="Expected plot method to be called six times!")
(args1, kwargs1), (args2, kwargs2) = scatter_method.mock.call_args_list
self.assertIn(len(args1[0]), [663, 731], msg="Incorrect number of points in subfigure 1!")
self.assertEqual(len(args1[0]), len(args1[1]), msg="Incorrect number of points in subfigure 1!")
self.assertIn(len(args2[0]), [663, 731], msg="Incorrect number of points in subfigure 2!")
self.assertEqual(len(args2[0]), len(args2[1]), msg="Incorrect number of points in subfigure 2!")
def test_calls(self):
method = spy_decorator(pd.core.series.Series.corr, "corr")
f_method = spy_decorator(pd.core.frame.DataFrame.corr, "corr")
with patch(ph("suicide_fractions"), wraps=suicide_fractions) as psf,\
patch(ph("pd.read_html"), wraps=pd.read_html) as phtml,\
patch.object(pd.core.series.Series, "corr", new=method),\
patch.object(pd.core.frame.DataFrame, "corr", new=f_method),\
patch(ph("suicide_weather"), wraps=suicide_weather) as psw:
main()
psf.assert_called_once()
psw.assert_called_once()
phtml.assert_called_once()
if not f_method.mock.called:
method.mock.assert_called()
args, kwargs = method.mock.call_args
else:
args, kwargs = f_method.mock.call_args
correct = ((len(args) > 1 and args[1] == "spearman") or
("method" in kwargs and kwargs["method"] == "spearman"))
self.assertTrue(correct,
msg="You did not compute Spearman correlation!")
out = get_out()
self.assertRegex(out,
r"Suicide DataFrame has \d+ rows",
msg="Output line about Suicide was incorrect!")
self.assertRegex(out,
r"Temperature DataFrame has \d+ rows",
msg="Output line about Temperature was incorrect!")
self.assertRegex(out,
r"Common DataFrame has \d+ rows",
msg="Output line about Common was incorrect!")
self.assertRegex(out,
r"Spearman correlation:\s+[+-]?\d+\.\d+",
msg="Output line about correlation was incorrect!")
def test_calls(self):
predict_method = spy_decorator(
sklearn.naive_bayes.MultinomialNB.predict, "predict")
score_method = spy_decorator(sklearn.naive_bayes.MultinomialNB.score,
"score")
fit_method = spy_decorator(sklearn.naive_bayes.MultinomialNB.fit,
"fit")
with patch(ph("sklearn.model_selection.train_test_split"),
wraps=sklearn.model_selection.train_test_split) as tts,\
patch(ph("sklearn.metrics.accuracy_score"),
wraps=sklearn.metrics.accuracy_score) as acs,\
patch.object(sklearn.naive_bayes.MultinomialNB, "fit", new=fit_method),\
patch.object(sklearn.naive_bayes.MultinomialNB, "predict", new=predict_method),\
patch.object(sklearn.naive_bayes.MultinomialNB, "score", new=score_method),\
patch(ph("sklearn.naive_bayes.MultinomialNB"),
wraps=sklearn.naive_bayes.MultinomialNB) as mnb:
random_state = 7
accuracy, total, misclassified = spam_detection(random_state,
fraction=0.1)
# Check that train_test_split is called with correct parameters
tts.assert_called_once()
args, kwargs = tts.call_args
self.assertIn("random_state",
kwargs,
msg="You did not specify random_state argument"
"to train_test_split function!")
self.assertEqual(kwargs["random_state"],
random_state,
msg="Incorrect random_state argument!")
if "train_size" in kwargs:
self.assertEqual(kwargs["train_size"],
0.75,
msg="Incorrect train_size argument!")
if "test_size" in kwargs:
self.assertEqual(kwargs["test_size"],
0.25,
msg="Incorrect test_size argument!")
# Check that accuracy_score is called
self.assertTrue(
acs.call_count == 1 or score_method.mock.call_count == 1,
msg=
"Expected that either the accuracy_score function or the score method is called exactly once!"
)
# Check that MultinomialNB is called
mnb.assert_called_once()
# Check that fit and predict methods of MultinomialNB object are called
predict_method.mock.assert_called()
fit_method.mock.assert_called()
def test_calls(self):
row = [2., 2., 0., 2.5, 0.76]
X, y = make_blobs(100,
int(row[0]),
centers=int(row[1]),
random_state=int(row[2]),
cluster_std=row[3])
predict_method = spy_decorator(sklearn.naive_bayes.GaussianNB.predict,
"predict")
fit_method = spy_decorator(sklearn.naive_bayes.GaussianNB.fit, "fit")
with patch(ph("sklearn.model_selection.train_test_split"),
wraps=sklearn.model_selection.train_test_split) as tts,\
patch(ph("sklearn.metrics.accuracy_score"),
wraps=sklearn.metrics.accuracy_score) as acs,\
patch.object(sklearn.naive_bayes.GaussianNB, "fit", new=fit_method),\
patch.object(sklearn.naive_bayes.GaussianNB, "predict", new=predict_method),\
patch(ph("sklearn.naive_bayes.GaussianNB"),
wraps=sklearn.naive_bayes.GaussianNB) as gnb:
acc = blob_classification(X, y)
# Check that train_test_split is called with correct parameters
tts.assert_called_once()
args, kwargs = tts.call_args
self.assertIn("random_state",
kwargs,
msg="You did not specify random_state argument"
"to train_test_split function!")
self.assertEqual(kwargs["random_state"],
0,
msg="Incorrect random_state argument!")
if "train_size" in kwargs:
self.assertEqual(kwargs["train_size"],
0.75,
msg="Incorrect train_size argument!")
elif "test_size" in kwargs:
self.assertEqual(kwargs["test_size"],
0.25,
msg="Incorrect test_size argument!")
# Check that accuracy_score is called
acs.assert_called_once()
# Check that GaussianNB is called
gnb.assert_called_once()
# Check that fit and predict methods of GaussianNB object are called
predict_method.mock.assert_called()
fit_method.mock.assert_called()
def test_gaussian(self):
predict_method = spy_decorator(sklearn.naive_bayes.GaussianNB.predict,
"predict")
fit_method = spy_decorator(sklearn.naive_bayes.GaussianNB.fit, "fit")
with patch.object(sklearn.naive_bayes.GaussianNB, "fit", new=fit_method),\
patch.object(sklearn.naive_bayes.GaussianNB, "predict", new=predict_method),\
patch(ph('sklearn.naive_bayes.GaussianNB'),
wraps=sklearn.naive_bayes.GaussianNB) as mock_gaussian:
acc = plant_classification()
mock_gaussian.assert_called_once()
# Check that fit and predict methods of GaussianNB object are called
predict_method.mock.assert_called()
fit_method.mock.assert_called()
def test_08_sbp_with_cigarets(self):
plot_method = spy_decorator(pd.core.frame.DataFrame.plot.scatter, "scatter")
with patch("matplotlib.pyplot.scatter", wraps=matplotlib.pyplot.scatter) as pltscatter,\
patch.object(pd.core.frame.DataFrame.plot, "scatter", new=plot_method),\
patch("statsmodels.graphics.regressionplots.abline_plot",
wraps=statsmodels.graphics.regressionplots.abline_plot) as abplot:
exec(exercises[0])
exec(exercises[1])
exec(exercises[2])
exec(exercises[3])
exec(exercises[8])
myfit = locals()["fit"]
self.assertIn("sCIG", myfit.params, msg="Missing explanatory variable sCIG!")
self.assertAlmostEqual(myfit.params.sCIG, 3.7733, places=2,
msg="Incorrect coefficient for sCIG!")
interaction = find_interaction("sFRW", "sCIG", myfit.params)
found = interaction is not None
self.assertTrue(found, msg="Missing explanatory variable sFRW:sCIG!")
self.assertAlmostEqual(myfit.params[interaction], 3.6765, places=2,
msg="Incorrect coefficient for sFRW:sCIG!")
self.assertEqual(len(myfit.params), 16, msg="Expected 15 explanatory variables and an intercept!")
#abplot.assert_called()
self.assertEqual(abplot.call_count, 3, msg="Expected abline_plot to be called three times!")
self.assertTrue(pltscatter.call_count > 0 or plot_method.mock.call_count > 0,
msg="Expected call to make a scatter plot!")
def test_calls(self):
merge_method = spy_decorator(pd.core.frame.DataFrame.merge, "merge")
with patch(ph("cycling_weather_continues"), wraps=cycling_weather_continues) as pcw,\
patch(ph("sklearn.linear_model.LinearRegression"), wraps=sklearn.linear_model.LinearRegression) as lr, \
patch(ph("pd.read_csv"), wraps=pd.read_csv) as prc,\
patch.object(pd.core.frame.DataFrame, "merge", new=merge_method),\
patch(ph("pd.merge"), wraps=pd.merge) as pmerge:
main()
pcw.assert_called_once()
lr.assert_called_once()
print(type(lr))
if "fit_intercept" in lr.call_args[1]:
self.assertTrue(lr.call_args[1]["fit_intercept"],
msg="You did not fit the intercept!")
elif len(lr.call_args[0]) > 0:
self.assertTrue(lr.call_args[0][0],
msg="You did not fit the intercept!")
merge_method_called = merge_method.mock.call_count >= 1
merge_func_called = pmerge.call_count >= 1
self.assertTrue(merge_method_called or merge_func_called,
msg="You did not call merge method or function!")
self.assertEqual(
prc.call_count,
2,
msg="You should have called pd.read_csv exactly twice")
def test_calls(self):
merge_method = spy_decorator(pd.core.frame.DataFrame.merge, "merge")
with patch(ph("top_bands"), wraps=top_bands) as ptop,\
patch(ph("pd.read_csv"), wraps=pd.read_csv) as prc,\
patch.object(pd.core.frame.DataFrame, "merge", new=merge_method),\
patch(ph("pd.merge"), wraps=pd.merge) as pmerge:
main()
ptop.assert_called_once()
self.assertEqual(
prc.call_count,
2,
msg="You should have called pd.read_csv exactly twice")
self.assertTrue(pmerge.call_count == 1
or merge_method.mock.call_count == 1,
msg="Call merge exactly once!")
if pmerge.call_count >= 1:
args, kwargs = pmerge.call_args # function called
else:
args, kwargs = merge_method.mock.call_args # method called
self.assertTrue(
"left_on" in kwargs,
msg="You should have used 'left_on' argument of pd.merge!")
self.assertTrue(
"right_on" in kwargs,
msg="You should have used 'right_on' argument of pd.merge!")
params = [kwargs["left_on"], kwargs["right_on"]]
self.assertTrue(
("Artist" in params or ["Artist"] in params)
and ("Band" in params or ["Band"] in params),
msg="You should have merged on 'Artist' and 'Band' columns!")
def test_accuracy_called(self):
score_method = spy_decorator(sklearn.naive_bayes.GaussianNB.score,
"score")
with patch(ph('sklearn.metrics.accuracy_score'),
side_effect=sklearn.metrics.accuracy_score) as accuracy, \
patch.object(sklearn.naive_bayes.GaussianNB, "score", new=score_method):
acc = plant_classification()
try:
score_method.assert_called_once()
except:
accuracy.assert_called_once()
def test_calls(self):
method = spy_decorator(pd.core.frame.DataFrame.groupby, "groupby")
with patch(ph("suicide_fractions"), wraps=suicide_fractions) as psf,\
patch.object(pd.core.frame.DataFrame, "groupby", new=method) as pgroupby,\
patch(ph("pd.read_csv"), wraps=pd.read_csv) as prc:
main()
psf.assert_called_once()
prc.assert_called_once()
method.mock.assert_called_once()
args, kwargs = method.mock.call_args
correct = ((len(args) > 0 and args[0]== "country") or
("by" in kwargs and kwargs["by"] == "country"))
self.assertTrue(correct, msg="Wrong or missing argument to groupby method!")
def test_called(self):
method = spy_decorator(pd.core.frame.DataFrame.dropna, "dropna")
with patch.object(pd.core.frame.DataFrame, "dropna", new=method):
df = cyclists()
method.mock.assert_called()
self.assertEqual(method.mock.call_count,
2,
msg="Expected dropna method to be called twice!")
for args, kwargs in method.mock.call_args_list:
self.assertEqual(
kwargs["how"],
"all",
msg="Expected parameter 'all' to parameter 'how'!")
def test_calls(self):
method = spy_decorator(pd.core.frame.DataFrame.groupby, "groupby")
with patch(ph("commute"), wraps=commute) as pcommute,\
patch.object(pd.core.frame.DataFrame, "groupby", new=method),\
patch(ph("pd.read_csv"), wraps=pd.read_csv) as prc,\
patch(ph("plt.show")) as pshow,\
patch(ph("pd.to_datetime"), wraps=pd.to_datetime) as pdatetime:
main()
pcommute.assert_called_once()
prc.assert_called_once()
pshow.assert_called_once()
pdatetime.assert_called()
method.mock.assert_called()
def test_calls(self):
method = spy_decorator(pd.core.frame.DataFrame.plot, "plot")
with patch(ph("cyclists_per_day"), wraps=cyclists_per_day) as pcpd,\
patch.object(pd.core.frame.DataFrame, "plot", new=method),\
patch(ph("plt.plot")) as pplot,\
patch(ph("plt.show")) as pshow:
main()
pcpd.assert_called_once()
func_called = pplot.call_count == 1
method_called = method.mock.call_count == 1
self.assertTrue(
func_called or method_called,
msg=
"You must call either plt.plot or plot method of a DataFrame!")
pshow.assert_called_once()
def test_01_load(self):
#exec(exercises[0])
describe_method = spy_decorator(pd.core.frame.DataFrame.describe, "describe")
with patch("pandas.read_csv", wraps=pd.read_csv) as prc,\
patch.object(pd.core.frame.DataFrame, "describe", new=describe_method):
exec(exercises[1])
prc.assert_called()
#fram=int()
self.assertTrue("fram" in locals(), msg="DataFrame 'fram' was not loaded!")
myfram = locals()["fram"]
self.assertIsInstance(myfram, pd.core.frame.DataFrame,
msg="'fram' is not a DataFrame object!")
self.assertEqual(myfram.shape, (1394, 14),
msg="The read DataFrame had incorrect shape!")
#koe.assert_called()
describe_method.mock.assert_called()
def test_07_sbp_with_interactions_visualization(self):
plot_method = spy_decorator(pd.core.frame.DataFrame.plot.scatter, "scatter")
with patch("matplotlib.pyplot.scatter", wraps=matplotlib.pyplot.scatter) as pltscatter,\
patch.object(pd.core.frame.DataFrame.plot, "scatter", new=plot_method),\
patch("statsmodels.graphics.regressionplots.abline_plot",
wraps=statsmodels.graphics.regressionplots.abline_plot) as abplot:
exec(exercises[0])
exec(exercises[1])
exec(exercises[2])
exec(exercises[3])
exec(exercises[6])
exec(exercises[7])
myfit = locals()["fit"]
#abplot.assert_called()
self.assertEqual(abplot.call_count, 3, msg="Expected abline_plot to be called three times!")
self.assertTrue(pltscatter.call_count > 0 or plot_method.mock.call_count > 0,
msg="Expected call to make a scatter plot!")
def test_pca(self):
fit_method = spy_decorator(sklearn.decomposition.PCA.fit, "fit")
with patch.object(sklearn.decomposition.PCA, "fit", new=fit_method),\
patch(ph("sklearn.decomposition.PCA"), wraps=sklearn.decomposition.PCA) as mypca:
v, ev = explained_variance()
mypca.assert_called_once()
args, kwargs = mypca.call_args
if len(args) > 0:
self.assertEqual(args[0],
10,
msg="Expected parameter 10 to PCA function!")
fit_method.mock.assert_called()
args, kwargs = fit_method.mock.call_args
df = args[0]
self.assertEqual(
df.shape[0],
400,
msg="Incorrect number of rows in DataFrame to 'fit' method!")
self.assertEqual(
df.shape[1],
10,
msg="Incorrect number of columns in DataFrame to 'fit' method!"
)
