public void AddRequiredParametersTest()
{
var parameterA = new MockParameter() { Name = "ParamA", IsRequired = false };
var parameterB = new MockParameter() { Name = "ParamB", IsRequired = true};
var method = new MockMethod() { Name = "Method", Parameters = new Dictionary<string, IParameter>() };
method.Parameters.Add("ParamA", parameterA);
method.Parameters.Add("ParamB", parameterB);
var resource = new MockResource();
resource.Methods.Add("Method", method);
var resourceDecl = new CodeTypeDeclaration();
var typeProvider = new DefaultObjectTypeProvider("Schema");
// Confirm that the "service" parameter is added.
var decorator = new RequestConstructorDecorator(typeProvider);
CodeConstructor constructor = new CodeConstructor();
decorator.AddRequestParameters(resourceDecl, method, constructor, false);
Assert.AreEqual(1, constructor.Parameters.Count);
Assert.AreEqual("paramB", constructor.Parameters[0].Name);
Assert.AreEqual(1, constructor.Statements.Count);
// Check that optional parameters are added when the appropriate flag is set.
constructor = new CodeConstructor();
decorator.AddRequestParameters(resourceDecl, method, constructor, true);
Assert.AreEqual(2, constructor.Parameters.Count);
Assert.AreEqual("paramB", constructor.Parameters[0].Name);
Assert.AreEqual("paramA", constructor.Parameters[1].Name);
Assert.AreEqual(2, constructor.Statements.Count);
}
public void GenerateParameterPropertyTest()
{
var parameter = new MockParameter() { Name = "Param" };
var method = new MockMethod() { Name = "Method", Parameters = new Dictionary<string, IParameter>() };
method.Parameters.Add("Param", parameter);
var resource = new MockResource();
resource.Methods.Add("Method", method);
var resourceDecl = new CodeTypeDeclaration();
// Confirm that two properties and two fields are generated.
var decorator = new ParameterPropertyDecorator();
CodeTypeMemberCollection newMembers = decorator.GenerateParameterProperty(
parameter, method, resourceDecl, Enumerable.Empty<string>());
Assert.AreEqual(2, newMembers.Count); // Property + field.
Assert.AreEqual(0, resourceDecl.Members.Count);
// Check the generated property.
Assert.IsInstanceOf<CodeMemberField>(newMembers[0]);
CodeMemberProperty property = (CodeMemberProperty)newMembers[1];
Assert.AreEqual("Param", property.Name);
// Check that the property has a Key attribute.
Assert.AreEqual(1, property.CustomAttributes.Count);
Assert.AreEqual(
typeof(RequestParameterAttribute).FullName, property.CustomAttributes[0].AttributeType.BaseType);
Assert.AreEqual(
"Param", ((CodePrimitiveExpression) property.CustomAttributes[0].Arguments[0].Value).Value);
}
public void ConstructorTest()
{
MockMethod m = new MockMethod();
m.Name = "Test";
Assert.IsInstanceOf<MethodValidator>(new MethodValidator(m, new ParameterCollection()));
}
public void AddBodyParameterTest()
{
var method = new MockMethod() { Name = "Method", Parameters = new Dictionary<string, IParameter>() };
var typeProvider = new DefaultObjectTypeProvider("Schema");
// Confirm that no body parameter is added.
var decorator = new RequestConstructorDecorator(typeProvider);
CodeConstructor constructor = new CodeConstructor();
method.HasBody = false;
decorator.AddBodyParameter(constructor, method);
Assert.AreEqual(0, constructor.Parameters.Count);
Assert.AreEqual(0, constructor.Statements.Count);
// Confirm that a required body parameter is added.
method.RequestType = "MySchema";
method.HasBody = true;
constructor = new CodeConstructor();
decorator.AddBodyParameter(constructor, method);
Assert.AreEqual(1, constructor.Parameters.Count);
Assert.AreEqual("body", constructor.Parameters[0].Name);
Assert.AreEqual("Schema.MySchema", constructor.Parameters[0].Type.BaseType);
Assert.AreEqual(1, constructor.Statements.Count);
}
public void DecorateClassTest()
{
var method = new MockMethod() { Name = "Method", Parameters = new Dictionary<string, IParameter>() };
method.Parameters.Add("Param", new MockParameter() { Name = "Param" });
var resource = new MockResource();
resource.Methods.Add("Method", method);
var resourceDecl = new CodeTypeDeclaration();
var requestDecl = new CodeTypeDeclaration();
var typeProvider = new DefaultObjectTypeProvider("Schema");
// Confirm that the decorator has run correctly.
var decorator = new RequestConstructorDecorator(typeProvider) { CreateOptionalConstructor = true };
decorator.DecorateClass(resource, method, requestDecl, resourceDecl);
Assert.AreEqual(2, requestDecl.Members.Count); // 2 Constructors.
Assert.IsInstanceOf<CodeConstructor>(requestDecl.Members[0]);
Assert.AreEqual(0, resourceDecl.Members.Count);
// Test the decorator without optional parameters.
requestDecl = new CodeTypeDeclaration();
decorator.CreateOptionalConstructor = false;
decorator.DecorateClass(resource, method, requestDecl, resourceDecl);
Assert.AreEqual(1, requestDecl.Members.Count); // 1 Constructor.
Assert.IsInstanceOf<CodeConstructor>(requestDecl.Members[0]);
Assert.AreEqual(0, resourceDecl.Members.Count);
}
public void ConstructorTest()
{
MockMethod m = new MockMethod();
m.Name = "Test";
Assert.IsInstanceOf <MethodValidator>(new MethodValidator(m, new ParameterCollection()));
}
public void ValidateRegexTest()
{
IMethod m = new MockMethod();
var dict = new JsonDictionary { { "name", "test" }, { "pattern", ".+" } };
var p = ServiceFactory.Default.CreateParameter("test", dict);
var inputData = new ParameterCollection();
var validator = new MethodValidator(m, inputData);
Assert.IsTrue(validator.ValidateRegex(p, "Test"));
}
public void DecorateClassNonBodyTest()
{
var decorator = new BodyPropertyDecorator(new DefaultObjectTypeProvider("Schema"));
var resource = new MockResource();
var method = new MockMethod() { Name = "Test", HasBody = false };
var decl = new CodeTypeDeclaration();
var resourceDecl = new CodeTypeDeclaration();
decorator.DecorateClass(resource, method, decl, resourceDecl);
Assert.AreEqual(0, decl.Members.Count);
}
public void ValidateRegexTest()
{
IMethod m = new MockMethod();
var dict = new JsonDictionary { { "name", "test" }, { "pattern", ".+" } };
var jsonObj = new KeyValuePair<string, object>("test", dict);
var p = new ParameterFactory.BaseParameter(jsonObj);
var inputData = new ParameterCollection();
var validator = new MethodValidator(m, inputData);
Assert.IsTrue(validator.ValidateRegex(p, "Test"));
}
public void ValidateRegexTest()
{
IMethod m = new MockMethod();
var dict = new JsonDictionary {
{ "name", "test" }, { "pattern", ".+" }
};
var p = ServiceFactory.Default.CreateParameter("test", dict);
var inputData = new ParameterCollection();
var validator = new MethodValidator(m, inputData);
Assert.IsTrue(validator.ValidateRegex(p, "Test"));
}
public void DecorateClassTest()
{
var decorator = new ServiceRequestInheritanceDecorator(new DefaultObjectTypeProvider("Schema"));
var resource = new MockResource();
var method = new MockMethod() { ResponseType = "MySchema" };
var decl = new CodeTypeDeclaration();
var resourceDecl = new CodeTypeDeclaration();
// Check for ": ServiceRequest<Schema.MySchema>".
decorator.DecorateClass(resource, method, decl, resourceDecl);
Assert.AreEqual(1, decl.BaseTypes.Count);
Assert.AreEqual(typeof(ServiceRequest<>).FullName, decl.BaseTypes[0].BaseType);
Assert.AreEqual(1, decl.BaseTypes[0].TypeArguments.Count);
Assert.AreEqual("Schema.MySchema", decl.BaseTypes[0].TypeArguments[0].BaseType);
}
public void DecorateClassTest()
{
var decorator = new BodyPropertyDecorator(new DefaultObjectTypeProvider("Schema"));
var resource = new MockResource();
var method = new MockMethod() { Name = "Test", RequestType = "SomeSchema", HasBody = true };
var decl = new CodeTypeDeclaration();
var resourceDecl = new CodeTypeDeclaration();
decorator.DecorateClass(resource, method, decl, resourceDecl);
Assert.AreEqual(3, decl.Members.Count);
Assert.IsInstanceOf<CodeMemberField>(decl.Members[0]);
Assert.IsInstanceOf<CodeMemberProperty>(decl.Members[1]);
Assert.AreEqual("Body", decl.Members[1].Name);
Assert.IsInstanceOf<CodeMemberMethod>(decl.Members[2]);
Assert.AreEqual("GetBody", decl.Members[2].Name);
}
public void CreateMethodComment()
{
var method = new MockMethod();
var instance = new DefaultEnglishCommentCreator();
method.Description = "A Test description";
CodeCommentStatementCollection result = instance.CreateMethodComment(method);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
Assert.IsNotNull(result[0].Comment);
Assert.AreEqual("<summary>A Test description</summary>", result[0].Comment.Text);
method.Description = "A <nasty> \"description\"";
result = instance.CreateMethodComment(method);
Assert.AreEqual("<summary>A <nasty> "description"</summary>", result[0].Comment.Text);
}
public void DecorateClassTest()
{
var method = new MockMethod() { Name = "Method", Parameters = new Dictionary<string, IParameter>()};
method.Parameters.Add("Param", new MockParameter() { Name = "Param"});
method.Parameters.Add("Param2", new MockParameter() { Name = "Param2"});
var resource = new MockResource();
resource.Methods.Add("Method", method);
var resourceDecl = new CodeTypeDeclaration();
var requestDecl = new CodeTypeDeclaration();
// Confirm that the decorator adds the two parameters as properties with a backing field each.
var decorator = new ParameterPropertyDecorator();
decorator.DecorateClass(resource, method, requestDecl, resourceDecl);
Assert.AreEqual(4, requestDecl.Members.Count); // 2 properties + 2 field.
Assert.AreEqual(0, resourceDecl.Members.Count);
}
public void ValidateRegexTest()
{
IMethod m = new MockMethod();
var dict = new JsonDictionary {
{ "name", "test" }, { "pattern", ".+" }
};
var jsonObj = new KeyValuePair <string, object>("test", dict);
var p = new ParameterFactory.BaseParameter(jsonObj);
var inputData = new ParameterCollection();
var validator = new MethodValidator(m, inputData);
Assert.IsTrue(validator.ValidateRegex(p, "Test"));
}
public void CreateConstructorTest()
{
var parameter = new MockParameter() { Name = "Param", IsRequired = true };
var method = new MockMethod() { Name = "Method", Parameters = new Dictionary<string, IParameter>() };
method.Parameters.Add("Param", parameter);
var resource = new MockResource();
resource.Methods.Add("Method", method);
var resourceDecl = new CodeTypeDeclaration();
var typeProvider = new DefaultObjectTypeProvider("Schema");
// Confirm that the "service" parameter is added.
var decorator = new RequestConstructorDecorator(typeProvider);
CodeConstructor constructor = decorator.CreateRequiredConstructor(resourceDecl, method, false);
Assert.AreEqual(2, constructor.Parameters.Count);
Assert.AreEqual("service", constructor.Parameters[0].Name);
Assert.AreEqual(1, constructor.BaseConstructorArgs.Count);
}
private void AssertBody(bool gzipEnabled, string body,
Action <Request, WebHeaderCollection, byte[]> additionalAsserts)
{
// Create the request.
var mockservice = new MockService {
GZipEnabled = gzipEnabled
};
var mockmethod = new MockMethod {
HttpMethod = "GET", Name = "Test", RestPath = "https://example.com"
};
var request = (Request)Request.CreateRequest(mockservice, mockmethod);
var headers = new WebHeaderCollection();
// Create a mock webrequest.
var requestStream = new MemoryStream();
var mockWebrequest = new Mock <WebRequest>();
mockWebrequest.Setup(r => r.EndGetRequestStream(It.IsAny <IAsyncResult>())).Returns(requestStream);
mockWebrequest.Setup(r => r.Headers).Returns(headers);
var waitHandle = new System.Threading.AutoResetEvent(false);
// Call the method we are testing
request.WithBody(body);
Action <WebRequest> x = (r) => waitHandle.Set();
var mockasync = new Mock <IAsyncResult>();
mockasync.Setup(r => r.AsyncState).Returns(new object[] { mockWebrequest.Object, x });
request.EndAttachBody(mockasync.Object);
if (!waitHandle.WaitOne(3000))
{
Assert.Fail("AttachBody did not complete.");
}
// Confirm the results.
mockWebrequest.Verify(r => r.EndGetRequestStream(It.IsAny <System.IAsyncResult>()), Times.Once());
if (additionalAsserts != null)
{
additionalAsserts(request, headers, requestStream.ToArray());
}
}
public void ValidateEnumNullTest()
{
IMethod m = new MockMethod();
var dict = new JsonDictionary { { "name", "test" } };
// Create the parameter.
var p = ServiceFactory.Default.CreateParameter("test", dict);
var inputData = new ParameterCollection();
var validator = new MethodValidator(m, inputData);
// Confirm that the method validates enumerations correctly.
Assert.IsTrue(validator.ValidateEnum(p, "one"));
Assert.IsTrue(validator.ValidateEnum(p, "two"));
Assert.IsTrue(validator.ValidateEnum(p, "three"));
Assert.IsTrue(validator.ValidateEnum(p, "One"));
Assert.IsTrue(validator.ValidateEnum(p, ""));
}
public void DecorateClassTest()
{
var method = new MockMethod() { Name = "Method", Parameters = new Dictionary<string, IParameter>() };
method.Parameters.Add("Param", new MockParameter() { Name = "Param" });
var resource = new MockResource();
resource.Methods.Add("Method", method);
var resourceDecl = new CodeTypeDeclaration();
var requestDecl = new CodeTypeDeclaration();
// Confirm that the decorator has run correctly.
var decorator = new ServiceRequestFieldDecorator();
decorator.DecorateClass(resource, method, requestDecl, resourceDecl);
Assert.AreEqual(2, requestDecl.Members.Count); // 2 properties
Assert.IsInstanceOf<CodeMemberProperty>(requestDecl.Members[0]);
Assert.IsInstanceOf<CodeMemberProperty>(requestDecl.Members[1]);
Assert.AreEqual("ResourcePath", requestDecl.Members[0].Name);
Assert.AreEqual("MethodName", requestDecl.Members[1].Name);
}
public void ValidateEnumNullTest()
{
IMethod m = new MockMethod();
var dict = new JsonDictionary { { "name", "test" } };
// Create the parameter.
var jsonObj = new KeyValuePair<string, object>("test", dict);
var p = new ParameterFactory.BaseParameter(jsonObj);
var inputData = new ParameterCollection();
var validator = new MethodValidator(m, inputData);
// Confirm that the method validates enumerations correctly.
Assert.IsTrue(validator.ValidateEnum(p, "one"));
Assert.IsTrue(validator.ValidateEnum(p, "two"));
Assert.IsTrue(validator.ValidateEnum(p, "three"));
Assert.IsTrue(validator.ValidateEnum(p, "One"));
Assert.IsTrue(validator.ValidateEnum(p, ""));
}
public void ValidateEnumNullTest()
{
IMethod m = new MockMethod();
var dict = new JsonDictionary {
{ "name", "test" }
};
// Create the parameter.
var p = ServiceFactory.Default.CreateParameter("test", dict);
var inputData = new ParameterCollection();
var validator = new MethodValidator(m, inputData);
// Confirm that the method validates enumerations correctly.
Assert.IsTrue(validator.ValidateEnum(p, "one"));
Assert.IsTrue(validator.ValidateEnum(p, "two"));
Assert.IsTrue(validator.ValidateEnum(p, "three"));
Assert.IsTrue(validator.ValidateEnum(p, "One"));
Assert.IsTrue(validator.ValidateEnum(p, ""));
}
public void CreateMethodTest()
{
const string className = "TestClass";
var typeProvider = new DefaultObjectTypeProvider("Schema");
var commentCreator = new DefaultEnglishCommentCreator();
var generator = new RequestMethodResourceDecorator.ResourceGenerator(
className, typeProvider, commentCreator);
// Generate a method.
var decl = new CodeTypeDeclaration();
var resource = new MockResource();
var method = new MockMethod() { Name = "Test", Parameters = new Dictionary<string, IParameter>()};
method.Parameters.Add(
"a", new MockParameter() { Name = "a", ParameterType = "string", IsRequired = false });
method.Parameters.Add(
"b", new MockParameter() { Name = "b", ParameterType = "string", IsRequired = true });
CodeMemberMethod generatedMethod = generator.CreateMethod(decl, resource, method, true);
Assert.AreEqual("Test", generatedMethod.Name);
Assert.AreEqual(2, generatedMethod.Parameters.Count); // two parameters defined.
Assert.AreEqual(1, generatedMethod.Statements.Count); // one "new ...Request()" statement.
Assert.AreEqual("TestRequest", generatedMethod.ReturnType.BaseType);
}
public void AddIsMethodResultTest()
{
var dic = new Dictionary<JsonSchema, SchemaImplementationDetails>();
var schema = new JsonSchema();
var service = new MockService();
service.Schemas.Add("TestSchema", new MockSchema() { SchemaDetails = schema });
var method = new MockMethod() { ResponseType = "TestSchema"};
// Test parameter validation:
Assert.Throws<ArgumentNullException>(
() => ImplementationDetailsGenerator.AddIsMethodResult(null, service, method));
Assert.Throws<ArgumentNullException>(
() => ImplementationDetailsGenerator.AddIsMethodResult(dic, null, method));
Assert.Throws<ArgumentNullException>(
() => ImplementationDetailsGenerator.AddIsMethodResult(dic, service, (IMethod)null));
// Test single add:
ImplementationDetailsGenerator.AddIsMethodResult(dic, service, method);
Assert.AreEqual(dic.Count, 1);
var implDetails = dic[schema];
Assert.IsTrue(implDetails.IsMethodResult);
}
public void GenerateRequestClassDecoratorOrderTest()
{
var generator =
new RequestClassGenerator(
new IRequestDecorator[]
{
new MockRequestDecorator("One"), new MockRequestDecorator("Two"),
new MockRequestDecorator("Three")
});
var decl = new CodeTypeDeclaration();
var resource = new MockResource();
var method = new MockMethod();
// Check the order of the generated members.
var genClass = generator.GenerateRequestClass(resource, method, decl, Enumerable.Empty<string>());
Assert.AreEqual(3, genClass.Members.Count);
Assert.AreEqual("One", genClass.Members[0].Name);
Assert.AreEqual("Two", genClass.Members[1].Name);
Assert.AreEqual("Three", genClass.Members[2].Name);
}
private void AssertBody(bool gzipEnabled, string body,
Action<Request, WebHeaderCollection, byte[]> additionalAsserts)
{
// Create the request.
var mockservice = new MockService { GZipEnabled = gzipEnabled };
var mockmethod = new MockMethod { HttpMethod = "GET", Name = "Test", RestPath = "https://example.com" };
var request = (Request)Request.CreateRequest(mockservice, mockmethod);
var headers = new WebHeaderCollection();
// Create a mock webrequest.
var requestStream = new MemoryStream();
var mockWebrequest = new Mock<WebRequest>();
mockWebrequest
.Setup(r => r.BeginGetRequestStream(It.IsAny<AsyncCallback>(), It.IsAny<object>()))
.Callback((AsyncCallback res, object state) =>
{
Mock<IAsyncResult> async = new Mock<IAsyncResult>();
async.SetupGet(r => r.AsyncState).Returns(state);
res(async.Object);
});
mockWebrequest.Setup(r => r.EndGetRequestStream(It.IsAny<IAsyncResult>())).Returns(requestStream);
mockWebrequest.Setup(r => r.Headers).Returns(headers);
// Call the method we are testing
request.WithBody(body);
request.AttachBody(mockWebrequest.Object);
// Confirm the results.
mockWebrequest.Verify(
r => r.BeginGetRequestStream(It.IsAny<AsyncCallback>(), It.IsAny<object>()), Times.Once());
mockWebrequest.Verify(r => r.EndGetRequestStream(It.IsAny<IAsyncResult>()), Times.Once());
if (additionalAsserts != null)
{
additionalAsserts(request, headers, requestStream.ToArray());
}
}
private void AssertBody(bool gzipEnabled, string body,
Action<Request, WebHeaderCollection, byte[]> additionalAsserts)
{
// Create the request.
var mockservice = new MockService { GZipEnabled = gzipEnabled };
var mockmethod = new MockMethod { HttpMethod = "GET", Name = "Test", RestPath = "https://example.com" };
var request = (Request)Request.CreateRequest(mockservice, mockmethod);
var headers = new WebHeaderCollection();
// Create a mock webrequest.
var requestStream = new MemoryStream();
var mockWebrequest = new Mock<WebRequest>();
mockWebrequest.Setup(r => r.EndGetRequestStream(It.IsAny<IAsyncResult>())).Returns(requestStream);
mockWebrequest.Setup(r => r.Headers).Returns(headers);
var waitHandle = new System.Threading.AutoResetEvent(false);
// Call the method we are testing
request.WithBody(body);
Action<WebRequest> x = (r) => waitHandle.Set();
var mockasync = new Mock<IAsyncResult>();
mockasync.Setup(r => r.AsyncState).Returns(new object[] { mockWebrequest.Object, x });
request.EndAttachBody(mockasync.Object);
if (!waitHandle.WaitOne(3000))
{
Assert.Fail("AttachBody did not complete.");
}
// Confirm the results.
mockWebrequest.Verify(r => r.EndGetRequestStream(It.IsAny<System.IAsyncResult>()), Times.Once());
if (additionalAsserts != null)
{
additionalAsserts(request, headers, requestStream.ToArray());
}
}
public void GenerateBodyPropertyTest()
{
var decorator = new BodyPropertyDecorator(new DefaultObjectTypeProvider("Schema"));
var method = new MockMethod() { Name = "Test", RequestType = "SomeSchema", HasBody = true };
var bodyType = new CodeTypeReference(typeof(object));
CodeTypeMemberCollection newMembers = decorator.GenerateBodyProperty(method, bodyType);
// Confirm that the result consists out of a field and a property.
Assert.AreEqual(2, newMembers.Count);
CollectionAssert.AreEqual(
new[] { typeof(CodeMemberField), typeof(CodeMemberProperty) },
(from CodeTypeMember m in newMembers select m.GetType()));
}
public void AddIsMethodResultRecursionTest()
{
var dic = new Dictionary<JsonSchema, SchemaImplementationDetails>();
var schema = new JsonSchema();
var method = new MockMethod() { ResponseType = "TestSchema" };
var subresource = new MockResource();
subresource.Methods.Add("TestMethod", method);
var resource = new MockResource();
resource.Resources.Add("Subresource", subresource);
var service = new MockService();
service.Schemas.Add("TestSchema", new MockSchema { SchemaDetails = schema });
service.Resources.Add("TestResource", resource);
// Test parameter validation:
Assert.Throws<ArgumentNullException>(
() => ImplementationDetailsGenerator.AddIsMethodResult(null, service, service.Resources.Values));
Assert.Throws<ArgumentNullException>(
() => ImplementationDetailsGenerator.AddIsMethodResult(dic, null, service.Resources.Values));
Assert.Throws<ArgumentNullException>(
() => ImplementationDetailsGenerator.AddIsMethodResult(dic, service, (IEnumerable<IResource>) null));
// Test recursive add:
ImplementationDetailsGenerator.AddIsMethodResult(dic, service, service.Resources.Values);
Assert.AreEqual(dic.Count, 1);
var implDetails = dic[schema];
Assert.IsTrue(implDetails.IsMethodResult);
}
public void GenerateGetBodyOverrideTest()
{
var decorator = new BodyPropertyDecorator(new DefaultObjectTypeProvider("Schema"));
var method = new MockMethod() { Name = "Test", RequestType = "SomeSchema", HasBody = true };
CodeMemberMethod newMethod = decorator.GenerateGetBodyOverride(method);
Assert.AreEqual(ServiceRequest<object>.GetBodyMethodName, newMethod.Name);
Assert.AreEqual(MemberAttributes.Override | MemberAttributes.Family, newMethod.Attributes);
Assert.AreEqual(0, newMethod.Parameters.Count);
Assert.AreEqual(typeof(object).FullName, newMethod.ReturnType.BaseType);
Assert.AreEqual(1, newMethod.Statements.Count);
}
public void GenerateRequestClassTest()
{
var decorator = new CountingRequestDecorator();
var generator = new RequestClassGenerator(new IRequestDecorator[] { decorator });
var decl = new CodeTypeDeclaration();
// Create a test resource.
var resource = new MockResource();
MockMethod method = new MockMethod() { Name = "MethodA" };
resource.Methods.Add("MethodA", method);
// Run the generator
CodeTypeDeclaration newClass = generator.GenerateRequestClass(resource, method, decl, new string[0]);
Assert.IsNotNull(newClass);
Assert.AreEqual(1, decorator.TimesCalled);
Assert.AreEqual(0, newClass.Members.Count);
}
