public async Task SayHelloServerStreamingTest()
{
// Arrange
var mockGreeter = new Mock <IGreeter>();
mockGreeter.Setup(m => m.Greet(It.IsAny <string>())).Returns((string s) => $"Hello {s}");
var service = new TesterService(mockGreeter.Object);
var cts = new CancellationTokenSource();
var callContext = TestServerCallContext.Create(cancellationToken: cts.Token);
var responseStream = new TestServerStreamWriter <HelloReply>(callContext);
// Act
using var call = service.SayHelloServerStreaming(new HelloRequest { Name = "Joe" }, responseStream, callContext);
// Assert
Assert.False(call.IsCompletedSuccessfully, "Method should run until cancelled.");
cts.Cancel();
await call;
responseStream.Complete();
var allMessages = new List <HelloReply>();
await foreach (var message in responseStream.ReadAllAsync())
{
allMessages.Add(message);
}
Assert.True(allMessages.Count >= 1);
Assert.Equal("Hello Joe 1", allMessages[0].Message);
}
public async Task SayHelloClientStreamingTest()
{
// Arrange
var service = new TesterService(CreateGreeterMock().Object);
var callContext = TestServerCallContext.Create();
var requestStream = new TestAsyncStreamReader <HelloRequest>(callContext);
// Act
using var call = service.SayHelloClientStreaming(requestStream, callContext);
requestStream.AddMessage(new HelloRequest {
Name = "James"
});
requestStream.AddMessage(new HelloRequest {
Name = "Jo"
});
requestStream.AddMessage(new HelloRequest {
Name = "Lee"
});
requestStream.Complete();
// Assert
var response = await call;
Assert.AreEqual("Hello James, Jo, Lee", response.Message);
}
public void ShouldFailValidationForNonArrayType()
{
var contractDictionary = new CaseInsensitiveDictionary <SchemaObject>
{
{ "TestArray", new SchemaObject
{
Type = "Array",
Items = new SchemaObject()
{
Type = "Integer"
},
} }
};
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "TestArray", "123" }
};
var testerService = new TesterService();
var result = testerService.DoAllMessageValuesMatchDataTypes(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeFalse();
result.MessageErrors[0].ShouldBe("\"123\" does not match the required data type for TestArray (array).");
}
public void AreAllElementsInMessageContainedInContractShouldReturnValidContract()
{
var contractDictionary = new CaseInsensitiveDictionary <SchemaObject>
{
{ "Name", new SchemaObject
{
Type = "String"
} },
{ "Age", new SchemaObject
{
Type = "Integer"
} }
};
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "Name", "Robert" },
{ "Age", "31" }
};
var testService = new TesterService();
var result = testService.AreAllElementsInMessageContainedInContract(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeTrue();
}
public void ShouldFailValidationForArrayTypeWithIncorrectItemType(string dataType, string format, string itemString)
{
var contractDictionary = new CaseInsensitiveDictionary <SchemaObject>
{
{ "Array", new SchemaObject
{
Type = "Array",
Items = new SchemaObject
{
Type = dataType,
Format = format
}
} }
};
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "Array", $"[\"{itemString}\"]" }
};
var testerService = new TesterService();
var result = testerService.DoAllMessageValuesMatchDataTypes(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeFalse();
result.MessageErrors[0].ShouldBe($"An item in the Items array for Array does not match the required data type ({format ?? dataType}).");
}
public void ShouldFailValidationForArrayTypeWithLessThanMinItems()
{
var contractDictionary = new CaseInsensitiveDictionary <SchemaObject>
{
{ "Array", new SchemaObject
{
Type = "Array",
Items = new SchemaObject()
{
Type = "Integer"
},
MinItems = 2
} }
};
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "Array", "[\"1\"]" }
};
var testerService = new TesterService();
var result = testerService.DoAllMessageValuesMatchDataTypes(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeFalse();
result.MessageErrors[0].ShouldBe("The Items array for Array does not have the minimum number (2) of items required.");
}
public void AreAllElementsCorrectDataTypeShouldReturnInvalidContract()
{
var contractDictionary = SampleContractDictionary();
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "Name", "123" },
{ "Age", "NotANumber" },
{ "BigNumber", "NotANumber" },
{ "Id", "" },
{ "Birthday", "" }
};
var testerService = new TesterService();
var result = testerService.DoAllMessageValuesMatchDataTypes(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeFalse();
result.MessageErrors.ShouldBe(new[]
{
"\"NotANumber\" does not match the required data type for Age (Integer).",
"\"NotANumber\" does not match the required data type for BigNumber (Integer).",
"\"\" does not match the required format for Id (Guid)."
});
}
public void ShouldValidateArrayType()
{
var contractDictionary = new CaseInsensitiveDictionary <SchemaObject>
{
{ "Array", new SchemaObject
{
Type = "Array",
Items = new SchemaObject()
{
Type = "Integer"
}
} }
};
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "Array", "[\"134435\"]" }
};
var testerService = new TesterService();
var result = testerService.DoAllMessageValuesMatchDataTypes(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeTrue();
}
public async Task SayHelloBidirectionStreamingTest()
{
// Arrange
var service = new TesterService(NullLoggerFactory.Instance.CreateLogger <TesterService>());
var callContext = TestServerCallContext.Create();
var requestStream = new TestAsyncStreamReader <HelloRequest>(callContext);
var responseStream = new TestServerStreamWriter <HelloReply>(callContext);
//Act
var call = service.SayHelloBidirectionalStreaming(requestStream, responseStream, callContext);
//Assert
requestStream.AddMessage(new HelloRequest {
Name = "James"
});
Assert.AreEqual("Hello James", (await responseStream.ReadNextAsync()) !.Message);
requestStream.AddMessage(new HelloRequest {
Name = "Jo"
});
Assert.AreEqual("Hello Jo", (await responseStream.ReadNextAsync()) !.Message);
requestStream.Complete();
await call;
responseStream.Complete();
Assert.IsNull(await responseStream.ReadNextAsync());
}
public async Task SayHelloClientStreamingTest()
{
//Arrange
var service = new TesterService(NullLoggerFactory.Instance.CreateLogger <TesterService>());
var callContext = TestServerCallContext.Create();
var requestStream = new TestAsyncStreamReader <HelloRequest>(callContext);
//Act
var call = service.SayHelloClientStreaming(requestStream, callContext);
requestStream.AddMessage(new HelloRequest {
Name = "James"
});
requestStream.AddMessage(new HelloRequest {
Name = "Jo"
});
requestStream.AddMessage(new HelloRequest {
Name = "Lee"
});
requestStream.Complete();
//Assert
var response = await call;
Assert.AreEqual("Hello James, Jo, Lee", response.Message);
}
public async Task SayHelloServerStreamingTest()
{
// Arrange
var service = new TesterService(NullLoggerFactory.Instance.CreateLogger <TesterService>());
var cts = new CancellationTokenSource();
var callContext = TestServerCallContext.Create(cancellationToken: cts.Token);
var responseStream = new TestServerStreamWriter <HelloReply>(callContext);
// Act
var call = service.SayHelloServerStreaming(new Test.HelloRequest {
Name = "Joe"
}, responseStream, callContext);
//Assert
Assert.IsFalse(call.IsCompletedSuccessfully, "Method should run until cancelled.");
cts.Cancel();
await call;
responseStream.Complete();
var allMessages = new List <HelloReply>();
await foreach (var message in responseStream.ReadAllAsync())
{
allMessages.Add(message);
}
Assert.GreaterOrEqual(allMessages.Count, 1);
Assert.AreEqual("How are you Joe? 1", allMessages[0].Message);
}
public async Task SayHelloClientStreamingTest()
{
// Arrange
var mockGreeter = new Mock <IGreeter>();
mockGreeter.Setup(m => m.Greet(It.IsAny <string>())).Returns((string s) => $"Hello {s}");
var service = new TesterService(mockGreeter.Object);
var callContext = TestServerCallContext.Create();
var requestStream = new TestAsyncStreamReader <HelloRequest>(callContext);
// Act
using var call = service.SayHelloClientStreaming(requestStream, callContext);
requestStream.AddMessage(new HelloRequest {
Name = "James"
});
requestStream.AddMessage(new HelloRequest {
Name = "Jo"
});
requestStream.AddMessage(new HelloRequest {
Name = "Lee"
});
requestStream.Complete();
// Assert
var response = await call;
Assert.Equal("Hello James, Jo, Lee", response.Message);
}
public void AreAllElementsContractContainedInMessageShouldReturnInvalidContract()
{
var contractDictionary = new CaseInsensitiveDictionary <SchemaObject>
{
{ "Name", new SchemaObject
{
Type = "String"
} },
{ "Age", new SchemaObject
{
Type = "Integer"
} }
};
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "Name", "Robert" }
};
var testService = new TesterService();
var result = testService.AreAllElementsInContractContainedInMessage(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeFalse("Message is missing expected property \"Age\".");
}
public void TestInitializeAttribute()
{
IDigitalIO digitalIO = digitalIOStub;
IDriver driver = driverStub;
IValveManager valveManager = valveManagerStub;
testerService = new TesterService(digitalIO, driver, valveManager);
}
public void MessageShouldBeAValidContract(string contract, string message)
{
var testService = new TesterService();
var result = testService.Execute(contract, message);
result.IsMessageValid.ShouldBeTrue();
}
public void TestInitializeAttribute()
{
digitalIOMock = new Mock <IDigitalIO>();
driverMock = new Mock <IDriver>();
valveManagerMock = new Mock <IValveManager>();
configurationSettings = new ConfigurationSettings();
testerService = new TesterService(digitalIOMock.Object, driverMock.Object, valveManagerMock.Object);
}
public void MessageShouldNotBeInvalidJSON(string contract, string message)
{
var testService = new TesterService();
var result = testService.Execute(contract, message);
result.IsMessageValid.ShouldBeFalse();
result.MessageErrors[0].ShouldBe("Message contains invalid JSON.");
}
public void TryParseJSON_Detects_Missing_Bracket()
{
var testerService = new TesterService();
var result1 = testerService.TryParseJSON("{\"Name\": \"Erin\"", out var jsonObject1);
var result2 = testerService.TryParseJSON("\"Name\": \"Erin\"}", out var jsonObject2);
result1.ShouldBeFalse();
result2.ShouldBeFalse();
}
public void TryParseJSON_Passes_With_Valid_JSON()
{
var testerService = new TesterService();
var result1 = testerService.TryParseJSON("{\"Name\": \"Erin\"}", out var jsonObject1);
var result2 = testerService.TryParseJSON("{\"Age\": 5}", out var jsonObject2);
result1.ShouldBeTrue();
result2.ShouldBeTrue();
}
public void ContractShouldHaveAValidReferenceDefinition(string contract, string message)
{
var testService = new TesterService();
var result = testService.Execute(contract, message);
result.IsMessageValid.ShouldBeFalse();
result.MessageErrors[0].ShouldBe("Unable to test; reference definition is invalid.");
}
public void ContractShouldHaveValidOpenAPISchema(string contract, string message)
{
var testService = new TesterService();
var result = testService.Execute(contract, message);
result.IsMessageValid.ShouldBeFalse();
result.MessageErrors[0].ShouldBe("Unable to test; contract is not a valid OpenAPI schema.");
}
public static int Main(string[] args)
{
var testerService = new TesterService(new ConsoleLogger());
return
(Parser.Default.ParseArguments <PackageOptions, DeployOptions>(args)
.MapResult(
(PackageOptions options) => Run(() => testerService.Package(options)),
(DeployOptions options) => Run(() => testerService.Deploy(options)),
errors => 1));
}
public async Task SayHelloUnaryTest()
{
// Arrange
var service = new TesterService(NullLoggerFactory.Instance);
// Act
var response = await service.SayHelloUnary(new HelloRequest { Name = "Joe" }, TestServerCallContext.Create());
// Assert
Assert.AreEqual("Hello Joe", response.Message);
}
public async Task SayHelloUnaryTest()
{
// Arrange
var mockGreeter = CreateGreeterMock();
var service = new TesterService(mockGreeter.Object);
// Act
var response = await service.SayHelloUnary(new HelloRequest { Name = "Joe" }, TestServerCallContext.Create());
// Assert
mockGreeter.Verify(v => v.Greet("Joe"));
Assert.AreEqual("Hello Joe", response.Message);
}
public async Task SayHelloUnaryTest()
{
// Arrange
var mockGreeter = new Mock <IGreeter>();
mockGreeter.Setup(
m => m.Greet(It.IsAny <string>())).Returns((string s) => $"Hello {s}");
var service = new TesterService(mockGreeter.Object);
// Act
var response = await service.SayHelloUnary(
new HelloRequest { Name = "Joe" }, TestServerCallContext.Create());
// Assert
mockGreeter.Verify(v => v.Greet("Joe"));
Assert.Equal("Hello Joe", response.Message);
}
public void TryParseJSON_Detects_Quote_Mismatch()
{
var testerService = new TesterService();
var result1 = testerService.TryParseJSON("{\"Name\": Erin\"}", out var jsonObject1);
var result2 = testerService.TryParseJSON("{\"Name\": \"Erin}", out var jsonObject2);
var result3 = testerService.TryParseJSON("{\"Name: \"Erin\"}", out var jsonObject3);
var result4 = testerService.TryParseJSON("{Name\": \"Erin\"}", out var jsonObject4);
var result5 = testerService.TryParseJSON("{\"Age\": \"5}", out var jsonObject5);
var result6 = testerService.TryParseJSON("{\"Age\": 5\"}", out var jsonObject6);
result1.ShouldBeFalse();
result2.ShouldBeFalse();
result3.ShouldBeFalse();
result4.ShouldBeFalse();
result5.ShouldBeFalse();
// Assert.False(result6); // This test reveals the bug to be addressed by CT-7
}
public void AreAllElementsCorrectDataTypeShouldReturnValidContract()
{
var contractDictionary = SampleContractDictionary();
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "Name", "Robert" },
{ "Age", "31" },
{ "BigNumber", "1000000" },
{ "Id", "a21b2109-bd23-4205-ba53-b8df0fdd36bf" },
{ "Birthday", "2019-07-23" }
};
var testerService = new TesterService();
var result = testerService.DoAllMessageValuesMatchDataTypes(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeTrue();
}
public void ShouldValidateGuidFormat()
{
var contractDictionary = new CaseInsensitiveDictionary <SchemaObject>
{
{ "Id", new SchemaObject
{
Reference = "#/Guid",
} }
};
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "Id", "01234567-abcd-0123-abcd-0123456789ab" }
};
var testerService = new TesterService();
var result = testerService.DoAllMessageValuesMatchDataTypes(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeTrue();
}
public void PropertyNameShouldBeCaseInsensitive()
{
var contractDictionary = new CaseInsensitiveDictionary <SchemaObject>
{
{ "Id", new SchemaObject
{
Type = "String"
} }
};
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "ID", "testId" }
};
var testerService = new TesterService();
var result = testerService.DoAllMessageValuesMatchDataTypes(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeTrue();
}
public void ShouldValidateObjectType()
{
var contractDictionary = new CaseInsensitiveDictionary <SchemaObject>
{
{ "Object", new SchemaObject
{
Type = "Object"
} }
};
var messageKeyDictionary = new CaseInsensitiveDictionary <object>
{
{ "Object", new object() }
};
var testerService = new TesterService();
var result = testerService.DoAllMessageValuesMatchDataTypes(messageKeyDictionary, contractDictionary);
result.IsMessageValid.ShouldBeTrue();
}
