def test_mdtol_intercept(self): call_func = Mock() data = sentinel.data axis = sentinel.axis aggregator = Aggregator('', call_func) aggregator.aggregate(data, axis, wibble='wobble', mdtol=0.8) call_func.assert_called_once_with(data, axis=axis, wibble='wobble')
def test_mdtol_intercept(self): call_func = mock.Mock() data = mock.sentinel.data axis = mock.sentinel.axis aggregator = Aggregator("", call_func) aggregator.aggregate(data, axis, wibble="wobble", mdtol=0.8) call_func.assert_called_once_with(data, axis=axis, wibble="wobble")
def test_kwarg_pass_through_no_kwargs(self): call_func = Mock() data = sentinel.data axis = sentinel.axis aggregator = Aggregator('', call_func) aggregator.aggregate(data, axis) call_func.assert_called_once_with(data, axis=axis)
def test_kwarg_pass_through_no_kwargs(self): call_func = mock.Mock() data = mock.sentinel.data axis = mock.sentinel.axis aggregator = Aggregator("", call_func) aggregator.aggregate(data, axis) call_func.assert_called_once_with(data, axis=axis)
def test_kwarg_pass_through_init_kwargs(self): call_func = Mock() data = sentinel.data axis = sentinel.axis kwargs = dict(wibble='wobble', foo='bar') aggregator = Aggregator('', call_func, **kwargs) aggregator.aggregate(data, axis) call_func.assert_called_once_with(data, axis=axis, **kwargs)
def test_kwarg_pass_through_init_kwargs(self): call_func = mock.Mock() data = mock.sentinel.data axis = mock.sentinel.axis kwargs = dict(wibble="wobble", foo="bar") aggregator = Aggregator("", call_func, **kwargs) aggregator.aggregate(data, axis) call_func.assert_called_once_with(data, axis=axis, **kwargs)
def test_kwarg_pass_through_call_kwargs(self): call_func = mock.Mock() data = mock.sentinel.data axis = mock.sentinel.axis kwargs = dict(wibble='wobble', foo='bar') aggregator = Aggregator('', call_func) aggregator.aggregate(data, axis, **kwargs) call_func.assert_called_once_with(data, axis=axis, **kwargs)
def test_kwarg_pass_through_combined_kwargs(self): call_func = Mock() data = sentinel.data axis = sentinel.axis init_kwargs = dict(wibble='wobble', var=1.0) call_kwargs = dict(foo='foo', var=0.5) aggregator = Aggregator('', call_func, **init_kwargs) aggregator.aggregate(data, axis, **call_kwargs) expected_kwargs = init_kwargs.copy() expected_kwargs.update(call_kwargs) call_func.assert_called_once_with(data, axis=axis, **expected_kwargs)
def test_kwarg_pass_through_combined_kwargs(self): call_func = mock.Mock() data = mock.sentinel.data axis = mock.sentinel.axis init_kwargs = dict(wibble="wobble", var=1.0) call_kwargs = dict(foo="foo", var=0.5) aggregator = Aggregator("", call_func, **init_kwargs) aggregator.aggregate(data, axis, **call_kwargs) expected_kwargs = init_kwargs.copy() expected_kwargs.update(call_kwargs) call_func.assert_called_once_with(data, axis=axis, **expected_kwargs)
class Test_aggregate(tests.IrisTest): # These unit tests don't call a data aggregation function, they call a # mocked one i.e. the return values of the mocked data aggregation # function don't matter, only how these are dealt with by the aggregate # method. def setUp(self): self.TEST = Aggregator('test', None) self.array = ma.array([[1, 2, 3], [4, 5, 6]], mask=[[False, True, False], [True, False, False]], dtype=np.float64) self.expected_result_axis0 = ma.array([1, 2, 3], mask=None) self.expected_result_axis1 = ma.array([4, 5], mask=None) def test_masked_notol(self): # Providing masked array with no tolerance keyword (mdtol) provided. axis = 0 mock_return = self.expected_result_axis0.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis) self.assertMaskedArrayEqual(result, self.expected_result_axis0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_masked_above_tol(self): # Providing masked array with a high tolerance (mdtol) provided. axis = 0 mock_return = self.expected_result_axis0.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.55) self.assertMaskedArrayEqual(result, self.expected_result_axis0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.55) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_masked_below_tol(self): # Providing masked array with a tolerance on missing values, low # enough to modify the resulting mask for axis 0. axis = 0 result_axis_0 = self.expected_result_axis0.copy() result_axis_0.mask = np.array([True, True, False]) mock_return = ma.array([1, 2, 3], mask=None) with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.45) self.assertMaskedArrayAlmostEqual(result, result_axis_0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.45) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_masked_below_tol_alt(self): # Providing masked array with a tolerance on missing values, low # enough to modify the resulting mask for axis 1. axis = 1 result_axis_1 = self.expected_result_axis1.copy() result_axis_1.mask = np.array([True, True]) mock_return = self.expected_result_axis1.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.1) self.assertMaskedArrayAlmostEqual(result, result_axis_1) mock_method.assert_called_once_with(self.array, axis=axis) def test_unmasked_with_mdtol(self): # Providing aggregator with an unmasked array and tolerance specified # for missing data - ensure that result is unaffected. data = self.array.data axis = 0 mock_return = self.expected_result_axis0.data.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=0.5) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) axis = 1 mock_return = self.expected_result_axis1.data.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=0.5) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) def test_unmasked(self): # Providing aggregator with an unmasked array and no additional keyword # arguments ensure that result is unaffected. data = self.array.data axis = 0 mock_return = self.expected_result_axis0.data.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) axis = 1 mock_return = self.expected_result_axis1.data.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) def test_returning_array_len_one_mdtol(self): # Test the case when the data aggregation function returns a scalar and # turns it into a masked array. axis = -1 data = self.array.flatten() mock_return = 2 with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=1) self.assertMaskedArrayEqual(result, ma.array([2], mask=[False])) mock_method.assert_called_once_with(data, axis=axis) def test_returning_array_len_one_mdtol_alt(self): # Test the case when the data aggregation function returns a scalar # with no tolerance for missing data values and turns it into a masked # array of length one. axis = -1 data = self.array.flatten() mock_return = 2 with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=0) self.assertMaskedArrayEqual(result, ma.array([2], mask=[True])) mock_method.assert_called_once_with(data, axis=axis) def test_returning_non_masked_array_from_masked_array(self): # Providing a masked array, call_func returning a non-masked array, # resulting in a masked array output. axis = 0 mock_return = self.expected_result_axis0.data.copy() result_axis_0 = ma.array(mock_return, mask=[True, True, False]) with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.45) self.assertMaskedArrayAlmostEqual(result, result_axis_0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.data.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.45) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis)
class Test_aggregate(tests.IrisTest): # These unit tests don't call a data aggregation function, they call a # mocked one i.e. the return values of the mocked data aggregation # function don't matter, only how these are dealt with by the aggregate # method. def setUp(self): self.TEST = Aggregator('test', None) self.array = ma.array([[1, 2, 3], [4, 5, 6]], mask=[[False, True, False], [True, False, False]], dtype=np.float64) self.expected_result_axis0 = ma.array([1, 2, 3], mask=None) self.expected_result_axis1 = ma.array([4, 5], mask=None) def test_masked_notol(self): # Providing masked array with no tolerance keyword (mdtol) provided. axis = 0 mock_return = self.expected_result_axis0.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis) self.assertMaskedArrayEqual(result, self.expected_result_axis0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_masked_above_tol(self): # Providing masked array with a high tolerance (mdtol) provided. axis = 0 mock_return = self.expected_result_axis0.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.55) self.assertMaskedArrayEqual(result, self.expected_result_axis0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.55) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_masked_below_tol(self): # Providing masked array with a tolerance on missing values, low # enough to modify the resulting mask for axis 0. axis = 0 result_axis_0 = self.expected_result_axis0.copy() result_axis_0.mask = np.array([True, True, False]) mock_return = ma.array([1, 2, 3], mask=None) with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.45) self.assertMaskedArrayAlmostEqual(result, result_axis_0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.45) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_masked_below_tol_alt(self): # Providing masked array with a tolerance on missing values, low # enough to modify the resulting mask for axis 1. axis = 1 result_axis_1 = self.expected_result_axis1.copy() result_axis_1.mask = np.array([True, True]) mock_return = self.expected_result_axis1.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.1) self.assertMaskedArrayAlmostEqual(result, result_axis_1) mock_method.assert_called_once_with(self.array, axis=axis) def test_unmasked_with_mdtol(self): # Providing aggregator with an unmasked array and tolerance specified # for missing data - ensure that result is unaffected. data = self.array.data axis = 0 mock_return = self.expected_result_axis0.data.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=0.5) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) axis = 1 mock_return = self.expected_result_axis1.data.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=0.5) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) def test_unmasked(self): # Providing aggregator with an unmasked array and no additional keyword # arguments ensure that result is unaffected. data = self.array.data axis = 0 mock_return = self.expected_result_axis0.data.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) axis = 1 mock_return = self.expected_result_axis1.data.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) def test_returning_scalar_mdtol(self): # Test the case when the data aggregation function returns a scalar and # turns it into a masked array. axis = -1 data = self.array.flatten() mock_return = 2 with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=1) self.assertMaskedArrayEqual(result, ma.array(2, mask=False)) mock_method.assert_called_once_with(data, axis=axis) def test_returning_scalar_mdtol_alt(self): # Test the case when the data aggregation function returns a scalar # with no tolerance for missing data values and turns it into a masked # array. axis = -1 data = self.array.flatten() mock_return = 2 with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=0) self.assertMaskedArrayEqual(result, ma.array(2, mask=True)) mock_method.assert_called_once_with(data, axis=axis) def test_returning_non_masked_array_from_masked_array(self): # Providing a masked array, call_func returning a non-masked array, # resulting in a masked array output. axis = 0 mock_return = self.expected_result_axis0.data.copy() result_axis_0 = ma.array(mock_return, mask=[True, True, False]) with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.45) self.assertMaskedArrayAlmostEqual(result, result_axis_0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.data.copy() with patch.object(self.TEST, 'call_func', return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=.45) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_kwarg_pass_through_no_kwargs(self): call_func = Mock() data = sentinel.data axis = sentinel.axis aggregator = Aggregator('', call_func) aggregator.aggregate(data, axis) call_func.assert_called_once_with(data, axis=axis) def test_kwarg_pass_through_call_kwargs(self): call_func = Mock() data = sentinel.data axis = sentinel.axis kwargs = dict(wibble='wobble', foo='bar') aggregator = Aggregator('', call_func) aggregator.aggregate(data, axis, **kwargs) call_func.assert_called_once_with(data, axis=axis, **kwargs) def test_kwarg_pass_through_init_kwargs(self): call_func = Mock() data = sentinel.data axis = sentinel.axis kwargs = dict(wibble='wobble', foo='bar') aggregator = Aggregator('', call_func, **kwargs) aggregator.aggregate(data, axis) call_func.assert_called_once_with(data, axis=axis, **kwargs) def test_kwarg_pass_through_combined_kwargs(self): call_func = Mock() data = sentinel.data axis = sentinel.axis init_kwargs = dict(wibble='wobble', var=1.0) call_kwargs = dict(foo='foo', var=0.5) aggregator = Aggregator('', call_func, **init_kwargs) aggregator.aggregate(data, axis, **call_kwargs) expected_kwargs = init_kwargs.copy() expected_kwargs.update(call_kwargs) call_func.assert_called_once_with(data, axis=axis, **expected_kwargs) def test_mdtol_intercept(self): call_func = Mock() data = sentinel.data axis = sentinel.axis aggregator = Aggregator('', call_func) aggregator.aggregate(data, axis, wibble='wobble', mdtol=0.8) call_func.assert_called_once_with(data, axis=axis, wibble='wobble') def test_no_lazy_func(self): dummy_agg = Aggregator('custom_op', lambda x: 1) expected = 'custom_op aggregator does not support lazy operation' with self.assertRaisesRegexp(LazyAggregatorError, expected): dummy_agg.lazy_aggregate(np.arange(10), axis=0)
class Test_aggregate(tests.IrisTest): # These unit tests don't call a data aggregation function, they call a # mocked one i.e. the return values of the mocked data aggregation # function don't matter, only how these are dealt with by the aggregate # method. def setUp(self): self.TEST = Aggregator("test", None) self.array = ma.array( [[1, 2, 3], [4, 5, 6]], mask=[[False, True, False], [True, False, False]], dtype=np.float64, ) self.expected_result_axis0 = ma.array([1, 2, 3], mask=None) self.expected_result_axis1 = ma.array([4, 5], mask=None) def test_masked_notol(self): # Providing masked array with no tolerance keyword (mdtol) provided. axis = 0 mock_return = self.expected_result_axis0.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis) self.assertMaskedArrayEqual(result, self.expected_result_axis0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_masked_above_tol(self): # Providing masked array with a high tolerance (mdtol) provided. axis = 0 mock_return = self.expected_result_axis0.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=0.55) self.assertMaskedArrayEqual(result, self.expected_result_axis0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=0.55) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_masked_below_tol(self): # Providing masked array with a tolerance on missing values, low # enough to modify the resulting mask for axis 0. axis = 0 result_axis_0 = self.expected_result_axis0.copy() result_axis_0.mask = np.array([True, True, False]) mock_return = ma.array([1, 2, 3], mask=None) with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=0.45) self.assertMaskedArrayAlmostEqual(result, result_axis_0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=0.45) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_masked_below_tol_alt(self): # Providing masked array with a tolerance on missing values, low # enough to modify the resulting mask for axis 1. axis = 1 result_axis_1 = self.expected_result_axis1.copy() result_axis_1.mask = np.array([True, True]) mock_return = self.expected_result_axis1.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=0.1) self.assertMaskedArrayAlmostEqual(result, result_axis_1) mock_method.assert_called_once_with(self.array, axis=axis) def test_unmasked_with_mdtol(self): # Providing aggregator with an unmasked array and tolerance specified # for missing data - ensure that result is unaffected. data = self.array.data axis = 0 mock_return = self.expected_result_axis0.data.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=0.5) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) axis = 1 mock_return = self.expected_result_axis1.data.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=0.5) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) def test_unmasked(self): # Providing aggregator with an unmasked array and no additional keyword # arguments ensure that result is unaffected. data = self.array.data axis = 0 mock_return = self.expected_result_axis0.data.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) axis = 1 mock_return = self.expected_result_axis1.data.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis) self.assertArrayAlmostEqual(result, mock_return.copy()) mock_method.assert_called_once_with(data, axis=axis) def test_returning_scalar_mdtol(self): # Test the case when the data aggregation function returns a scalar and # turns it into a masked array. axis = -1 data = self.array.flatten() mock_return = 2 with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=1) self.assertMaskedArrayEqual(result, ma.array(2, mask=False)) mock_method.assert_called_once_with(data, axis=axis) def test_returning_scalar_mdtol_alt(self): # Test the case when the data aggregation function returns a scalar # with no tolerance for missing data values and turns it into a masked # array. axis = -1 data = self.array.flatten() mock_return = 2 with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(data, axis, mdtol=0) self.assertMaskedArrayEqual(result, ma.array(2, mask=True)) mock_method.assert_called_once_with(data, axis=axis) def test_returning_non_masked_array_from_masked_array(self): # Providing a masked array, call_func returning a non-masked array, # resulting in a masked array output. axis = 0 mock_return = self.expected_result_axis0.data.copy() result_axis_0 = ma.array(mock_return, mask=[True, True, False]) with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=0.45) self.assertMaskedArrayAlmostEqual(result, result_axis_0) mock_method.assert_called_once_with(self.array, axis=axis) axis = 1 mock_return = self.expected_result_axis1.data.copy() with mock.patch.object(self.TEST, "call_func", return_value=mock_return) as mock_method: result = self.TEST.aggregate(self.array, axis, mdtol=0.45) self.assertMaskedArrayEqual(result, self.expected_result_axis1) mock_method.assert_called_once_with(self.array, axis=axis) def test_kwarg_pass_through_no_kwargs(self): call_func = mock.Mock() data = mock.sentinel.data axis = mock.sentinel.axis aggregator = Aggregator("", call_func) aggregator.aggregate(data, axis) call_func.assert_called_once_with(data, axis=axis) def test_kwarg_pass_through_call_kwargs(self): call_func = mock.Mock() data = mock.sentinel.data axis = mock.sentinel.axis kwargs = dict(wibble="wobble", foo="bar") aggregator = Aggregator("", call_func) aggregator.aggregate(data, axis, **kwargs) call_func.assert_called_once_with(data, axis=axis, **kwargs) def test_kwarg_pass_through_init_kwargs(self): call_func = mock.Mock() data = mock.sentinel.data axis = mock.sentinel.axis kwargs = dict(wibble="wobble", foo="bar") aggregator = Aggregator("", call_func, **kwargs) aggregator.aggregate(data, axis) call_func.assert_called_once_with(data, axis=axis, **kwargs) def test_kwarg_pass_through_combined_kwargs(self): call_func = mock.Mock() data = mock.sentinel.data axis = mock.sentinel.axis init_kwargs = dict(wibble="wobble", var=1.0) call_kwargs = dict(foo="foo", var=0.5) aggregator = Aggregator("", call_func, **init_kwargs) aggregator.aggregate(data, axis, **call_kwargs) expected_kwargs = init_kwargs.copy() expected_kwargs.update(call_kwargs) call_func.assert_called_once_with(data, axis=axis, **expected_kwargs) def test_mdtol_intercept(self): call_func = mock.Mock() data = mock.sentinel.data axis = mock.sentinel.axis aggregator = Aggregator("", call_func) aggregator.aggregate(data, axis, wibble="wobble", mdtol=0.8) call_func.assert_called_once_with(data, axis=axis, wibble="wobble") def test_no_lazy_func(self): dummy_agg = Aggregator("custom_op", lambda x: 1) expected = "custom_op aggregator does not support lazy operation" with self.assertRaisesRegex(LazyAggregatorError, expected): dummy_agg.lazy_aggregate(np.arange(10), axis=0)