public void GetResponse_SingleModeDefaultIndexManyResponses_ReturnsFirstResponse()
{
// Arrange
var random = new Mock <IRandomService>();
var response1 = new Response();
var response2 = new Response();
var response3 = new Response();
var response4 = new Response();
var response5 = new Response();
var action = new EndpointAction
{
Mode = EndpointActionMode.Single,
Responses = new List <Response>
{
response1,
response2,
response3,
response4,
response5
}
};
// Act
var actualResponse = action.GetResponse(random.Object);
// Assert
Assert.Same(response1, actualResponse);
}
public void Validate_InvalidMethodAndModeAndActions_MergesErrors()
{
// Arrange
var validator = new EndpointActionValidator(_responseValidator.Object);
var section = new EndpointAction
{
Method = _defaultInvalidMethod,
Mode = _defaultInvalidMode,
Responses = _defaultValidResponses
};
var invalidValidationResult = new ValidationResult();
invalidValidationResult.AddError(new SectionName("$"), "Something broke");
_responseValidator.Setup(
m => m.Validate(It.IsAny <Response>(), It.IsAny <SectionName>())
).Returns(invalidValidationResult);
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.True(result.HasErrors);
Assert.Equal(3, result.Errors.Length);
}
public void GetResponse_RandomModeMultipleResponsesRandomHigherThanMinumum_ReturnsFirst()
{
// Arrange
var random = new Mock <IRandomService>();
random.Setup(m => m.GetRandomIntegerInclusive(It.IsAny <int>(), It.IsAny <int>())).Returns(3);
var response1 = new Response
{
RandomWeight = 1
};
var response2 = new Response
{
RandomWeight = 1
};
var action = new EndpointAction
{
Mode = EndpointActionMode.Random,
Responses = new List <Response>
{
response1,
response2
}
};
// Act
var actualResponse = action.GetResponse(random.Object);
// Assert
Assert.Same(response1, actualResponse);
}
public void GetResponse_SingleModeResponseIndexOutOfBounds_DefaultsToFirstResponse(int singleResponseIndex)
{
// Arrange
var random = new Mock <IRandomService>();
var response1 = new Response();
var response2 = new Response();
var response3 = new Response();
var action = new EndpointAction
{
Mode = EndpointActionMode.Single,
SingleResponseIndex = singleResponseIndex,
Responses = new List <Response>
{
response1,
response2,
response3
}
};
// Act
var actualResponse = action.GetResponse(random.Object);
// Assert
Assert.Same(response1, actualResponse);
}
public void GetResponse_SingleModeSpecificIndexManyResponses_ReturnsExpectedResponse(int singleResponseIndex, int expectedResponseIndex)
{
// Arrange
var random = new Mock <IRandomService>();
var response1 = new Response();
var response2 = new Response();
var response3 = new Response();
var response4 = new Response();
var response5 = new Response();
var responses = new List <Response>()
{
response1,
response2,
response3,
response4,
response5
};
var action = new EndpointAction
{
Mode = EndpointActionMode.Single,
SingleResponseIndex = singleResponseIndex,
Responses = responses
};
// Act
var actualResponse = action.GetResponse(random.Object);
// Assert
Assert.Same(responses[expectedResponseIndex], actualResponse);
}
public void When_passed_a_method_with_one_parameter()
{
var mi = _actions.GetMethod("OneParameter");
var action = new EndpointAction(_endpoint, mi);
action.InputModelType.ShouldEqual(typeof(TestActions.InputModel));
}
public void When_passed_a_method_with_no_parameters()
{
var mi = _actions.GetMethod("NoParameters");
var action = new EndpointAction(_endpoint, mi);
action.InputModelType.ShouldBeNull();
}
public void Constructor_DefaultMethod_IsAny()
{
// Arrange
var action = new EndpointAction();
// Assert
Assert.Equal("ANY", action.Method);
}
public void MatchedMethod_SetAsAny_AllMethodsReturnTrue(string givenMethod)
{
// Arrange
var action = new EndpointAction
{
Method = "ANY"
};
// Act
var matches = action.MatchesMethod(givenMethod);
// Assert
Assert.True(matches);
}
public void MatchedMethod_SetAsAnyWithVaryingCase_AllMethodsReturnTrue(string setMethod)
{
// Arrange
var action = new EndpointAction
{
Method = setMethod
};
// Act
var matches = action.MatchesMethod("");
// Assert
Assert.True(matches);
}
[InlineData("PoSt", "ANY")] // If any is the given method, it should still fail
public void MatchedMethod_MismatchingMethods_ReturnTrue(string setMethod, string givenMethod)
{
// Arrange
var action = new EndpointAction
{
Method = setMethod
};
// Act
var matches = action.MatchesMethod(givenMethod);
// Assert
Assert.False(matches);
}
public void Validate_DefaultValues_ReturnsNoError()
{
// Arrange
var validator = new EndpointActionValidator(_responseValidator.Object);
var section = new EndpointAction
{
Responses = _defaultValidResponses
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.False(result.HasErrors);
}
public void GetResponse_NoResponsesAvailable_ReturnsNull()
{
// Arrange
var random = new Mock <IRandomService>();
var action = new EndpointAction
{
Responses = null,
};
// Act
var response = action.GetResponse(random.Object);
// Assert
Assert.Null(response);
}
public void Validate_ValidMode_ReturnsSingleError(string mode)
{
// Arrange
var validator = new EndpointActionValidator(_responseValidator.Object);
var section = new EndpointAction
{
Mode = mode,
Responses = _defaultValidResponses
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.False(result.HasErrors);
}
public void GetResponse_SingleModeNullResponses_ReturnsNull()
{
// Arrange
var random = new Mock <IRandomService>();
var action = new EndpointAction
{
Mode = EndpointActionMode.Single,
Responses = null
};
// Act
var actualResponse = action.GetResponse(random.Object);
// Assert
Assert.Null(actualResponse);
}
public void Validate_AllAllowedNullValuesNull_ReturnsNoError()
{
// Arrange
var validator = new EndpointActionValidator(_responseValidator.Object);
var section = new EndpointAction
{
Mode = null,
Method = null,
Responses = _defaultValidResponses
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.False(result.HasErrors);
}
public void Validate_NullResponses_ReturnsSingleError()
{
// Arrange
var validator = new EndpointActionValidator(_responseValidator.Object);
var section = new EndpointAction
{
Responses = null
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.True(result.HasErrors);
var error = Assert.Single(result.Errors);
Assert.Equal(ErrorMessageFormatter.Format("$.responses", $"Action must have a responses array"), error);
}
public void Validate_EmptyActions_ReturnsSingleError()
{
// Arrange
var validator = new EndpointActionValidator(_responseValidator.Object);
var section = new EndpointAction
{
Responses = new List <Response>()
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.True(result.HasErrors);
var error = Assert.Single(result.Errors);
Assert.Equal(ErrorMessageFormatter.Format("$.responses", $"Responses array must have at least one item"), error);
}
public void Validate_InvalidMode_ReturnsSingleError(string mode)
{
// Arrange
var validator = new EndpointActionValidator(_responseValidator.Object);
var section = new EndpointAction
{
Mode = mode,
Responses = _defaultValidResponses
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.True(result.HasErrors);
var error = Assert.Single(result.Errors);
Assert.Equal(ErrorMessageFormatter.Format("$.mode", $"Invalid mode '{mode}'. Mode must be one of SINGLE, RANDOM, INTERCEPT."), error);
}
public void GetResponse_InterceptMode_ThrowsException()
{
// Arrange
var random = new Mock <IRandomService>();
var action = new EndpointAction
{
Mode = EndpointActionMode.Intercept,
Responses = new List <Response>
{
new Response()
}
};
// Act
var exception = Assert.Throws <NotImplementedException>(() => action.GetResponse(random.Object));
// Assert
Assert.Equal("Intercept mode is not currently supported", exception.Message);
}
public void Validate_InvalidMethod_ReturnsSingleError(string method)
{
// Arrange
var validator = new EndpointActionValidator(_responseValidator.Object);
var section = new EndpointAction
{
Method = method,
Responses = _defaultValidResponses
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.True(result.HasErrors);
var error = Assert.Single(result.Errors);
Assert.Equal(ErrorMessageFormatter.Format("$.method", $"Invalid method '{method}'. Method can only contain A-Z, a-z."), error);
}
public void Validate_MultipleActionsInArray_CallsActionValidatorForAllActions()
{
// Arrange
var validator = new EndpointValidator(_actionValidator.Object);
var action1 = new EndpointAction();
var action2 = new EndpointAction();
var action3 = new EndpointAction();
var section = new Endpoint
{
Path = _defaultValidPath,
Actions = new List <EndpointAction>
{
action1,
action2,
action3
}
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.False(result.HasErrors);
_actionValidator.Verify(m => m.Validate(
action1,
It.Is <SectionName>(s => s.PropertyPath == "$.actions[0]")
), Times.Once());
_actionValidator.Verify(m => m.Validate(
action2,
It.Is <SectionName>(s => s.PropertyPath == "$.actions[1]")
), Times.Once());
_actionValidator.Verify(m => m.Validate(
action3,
It.Is <SectionName>(s => s.PropertyPath == "$.actions[2]")
), Times.Once());
}
[InlineData(10, 0)] // Out of bounds
public void GetResponse_RandomModeMultipleResponsesVaryingWeights_ReturnsCorrectWeightedResponse(int randomValue, int responseIndex)
{
// Arrange
var random = new Mock <IRandomService>();
random.Setup(m => m.GetRandomIntegerInclusive(It.IsAny <int>(), It.IsAny <int>())).Returns(randomValue);
var response1 = new Response
{
RandomWeight = 3
};
var response2 = new Response
{
RandomWeight = 5
};
var response3 = new Response
{
RandomWeight = 1
};
var responses = new List <Response>
{
response1,
response2,
response3
};
var action = new EndpointAction
{
Mode = EndpointActionMode.Random,
Responses = responses
};
// Act
var actualResponse = action.GetResponse(random.Object);
// Assert
Assert.Same(responses[responseIndex], actualResponse);
}
public void Validate_MultipleResponsesInArray_CallsResponseValidatorForAllReponses()
{
// Arrange
var validator = new EndpointActionValidator(_responseValidator.Object);
var response1 = new Response();
var response2 = new Response();
var response3 = new Response();
var section = new EndpointAction
{
Responses = new List <Response>
{
response1,
response2,
response3
}
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.False(result.HasErrors);
_responseValidator.Verify(m => m.Validate(
response1,
It.Is <SectionName>(s => s.PropertyPath == "$.responses[0]")
), Times.Once());
_responseValidator.Verify(m => m.Validate(
response2,
It.Is <SectionName>(s => s.PropertyPath == "$.responses[1]")
), Times.Once());
_responseValidator.Verify(m => m.Validate(
response3,
It.Is <SectionName>(s => s.PropertyPath == "$.responses[2]")
), Times.Once());
}
public void Validate_SingleResponseInArray_CallsResponseValidator()
{
// Arrange
var validator = new EndpointActionValidator(_responseValidator.Object);
var response = new Response();
var section = new EndpointAction
{
Responses = new List <Response>
{
response
}
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.False(result.HasErrors);
_responseValidator.Verify(m => m.Validate(
response,
It.Is <SectionName>(s => s.PropertyPath == "$.responses[0]")
), Times.Once());
}
public void GetResponse_RandomModeSingleResponse_ReturnsSingleResponse(int weight)
{
// Arrange
var random = new Mock <IRandomService>();
var response = new Response
{
RandomWeight = weight
};
var action = new EndpointAction
{
Mode = EndpointActionMode.Random,
Responses = new List <Response>
{
response
}
};
// Act
var actualResponse = action.GetResponse(random.Object);
// Assert
Assert.Same(response, actualResponse);
}
public void GetResponse_InvalidModeMultipleResponses_DefaultsToSingleMode()
{
// Arrange
var random = new Mock <IRandomService>();
var response1 = new Response();
var response2 = new Response();
var action = new EndpointAction
{
Mode = "Something that's not even a mode and never will be",
SingleResponseIndex = 0,
Responses = new List <Response>
{
response1,
response2
}
};
// Act
var actualResponse = action.GetResponse(random.Object);
// Assert
Assert.Same(response1, actualResponse);
}
public void GetResponse_SingleModeSecondIndexTwoResponses_ReturnsFirstResponse()
{
// Arrange
var random = new Mock <IRandomService>();
var response1 = new Response();
var response2 = new Response();
var action = new EndpointAction
{
Mode = EndpointActionMode.Single,
SingleResponseIndex = 1,
Responses = new List <Response>
{
response1,
response2
}
};
// Act
var actualResponse = action.GetResponse(random.Object);
// Assert
Assert.Same(response2, actualResponse);
}
public static string GetString(this EndpointAction endpointAction)
{
return(Enum.GetName(typeof(EndpointAction), endpointAction));
}
