Mocking Framework

Create mocks for the depended-on components.
Define behaviors of the mocks.
Test the component of interest.
Qualify interactions between the component of interest and the mocked components.

Stubbing - define behaviour

Spying - intercept and remember

Create a mock test case for interactive use.

import matlab.mock.TestCase
testCase = TestCase.forInteractiveUse
testCase = 
  InteractiveTestCase with no properties.
 36 | 

Depended on Components

The day-trading algorithm has two dependencies: a data service to retrieve the stock price data and a broker to purchase the stock.

type DataService.m
classdef DataService
|     % a data service to retrieve the stock price data
|     
|     % Copyright 2018 MathWorks Inc.   
|     methods (Abstract,Static)
|         price = lookupPrice(ticker,date)
|     end
| end

In production code, there could be several concrete implementations of the DataService class, such as a BloombergDataService class.

Create Stub to Define Behavior

Create a mock for the data service dependency. The data service mock returns predefined values.

[stubDataService,dataServiceBehavior] = createMock(testCase,?DataService);
methods(stubDataService)
Methods for class matlab.mock.classes.DataServiceMock:
 44 | 
 45 | 
 46 | 
 47 | Static methods:
 48 | 
 49 | lookupPrice  

In the DataService class, the lookupPrice method is abstract and static. The mocking framework implements this method as concrete and static.

Define behavior for the data service mock.

import matlab.unittest.constraints.IsLessThan
yesterday = datetime('yesterday');
testCase.assignOutputsWhen(dataServiceBehavior.lookupPrice(...
    "FOO",yesterday),123);
testCase.assignOutputsWhen(dataServiceBehavior.lookupPrice(...
    "FOO",IsLessThan(yesterday)),234);
testCase.assignOutputsWhen(dataServiceBehavior.lookupPrice(...
    "BAR",yesterday),765);
testCase.assignOutputsWhen(dataServiceBehavior.lookupPrice(...
    "BAR",IsLessThan(yesterday)),543);

You can now call the mocked lookupPrice method.

p1 = stubDataService.lookupPrice("FOO",yesterday)
p1 = 123
p2 = stubDataService.lookupPrice("BAR",yesterday-days(5))
p2 = 543

Create Spy to Intercept Messages

Create a mock for the broker dependency.

[spyBroker,brokerBehavior] = createMock(testCase,'AddedMethods',{'buy'});
methods(spyBroker)
Methods for class matlab.mock.classes.Mock_1:
 50 | 
 51 | buy  
s2 = spyBroker.buy("inputs",[13 42])
s2 =
 52 | 
 53 |      []

Call Component Under Test

Call the trader function. Pass in the spyBroker and stubDataService mocks.

trader(stubDataService,spyBroker,"FOO",100)
trader(stubDataService,spyBroker,"FOO",75)
trader(stubDataService,spyBroker,"BAR",100)

Verify Function Interactions

Use the broker behavior object (the spy) to verify that the trader function calls the buy method, as expected.

Use the TestCase.verifyCalled method to verify that the trader function instructed the buy method to buy 100 shares of the FOO stock.

import matlab.mock.constraints.WasCalled;
testCase.verifyCalled(brokerBehavior.buy("FOO",100))
Interactive verification passed.

Verify that FOO stock was purchased two times, regardless of the specified number of shares. While the verifyCalled method is convenient to specify behavior, there is more functionality if you use the WasCalled constraint. For example, you can verify that a mocked method was called a specified number of times.

import matlab.unittest.constraints.IsAnything
testCase.verifyThat(brokerBehavior.buy("FOO",IsAnything), ...
    WasCalled('WithCount',2))
Interactive verification passed.

Verify that the buy method was not called requesting 100 shares of the BAR stock.

testCase.verifyNotCalled(brokerBehavior.buy("BAR",100))
Interactive verification passed.

Although the trader function was called requesting 100 shares of BAR stock, the stub defined yesterday's price for BAR to return a higher value than all days prior to yesterday. Therefore, the broker never buys stock "BAR".

Sample Class Using Property Validation

The ValidateProps class defines three properties with validation.

type ValidateProps.m
classdef ValidateProps
|     
|     % Copyright 2018 MathWorks
|     properties
|         Location(1,3) double {mustBeReal, mustBeFinite}
|         Label(1,:) char {mustBeMember(Label,{'High','Medium','Low'})} = 'Low'
|         State(1,1) matlab.lang.OnOffSwitchState
|     end
| end

Location must be a 1-by-3 array of class double whose values are real, finite numbers.
Label must be a char vector that is either 'High', 'Medium', or 'Low'.
State must be an enumeration member of the matlab.lang.OnOffSwitchState class (off or on).

Validation at Instantiation

Creating an object of the ValidateProps class performs the validation on implicit and explicit default values:

a = ValidateProps
a = 
  ValidateProps with properties:
39 | 
40 |     Location: [0 0 0]
41 |        Label: 'Low'
42 |        State: off
43 | 

When creating the object, MATLAB:

Initializes the Location property value to [0 0 0] to satisfy the size and class requirements.
Sets the Label property to its default value, 'Low'. The default value must be a member of the allowed set of values. The empty char implicit default value would cause an error.
Sets the State property to the off enumeration member defined by the matlab.lang.OnOffSwitchState class.

Property Validation and Errors

a.Label = 'High'
a = 
  ValidateProps with properties:
44 | 
45 |     Location: [0 0 0]
46 |        Label: 'High'
47 |        State: off
48 | 

The State property accepts values of 'on' and 'off' and logical true, false, 1, or 0.

a.State = true
a = 
  ValidateProps with properties:
49 | 
50 |     Location: [0 0 0]
51 |        Label: 'High'
52 |        State: on
53 | 

Property Validation Errors

a.Location = [54 55]
Error setting property 'Location' of class 'ValidateProps':
Size of value must match specified dimensions 1×3 or be scalar.