public void FieldsMode_UnitTest()
{
ExecuteProperty(
() =>
// Create Test Instance
{
JsonWorkItem instance = GetInstance();
return(instance);
},
// Create Set Value
instance =>
{
string setValue = default(String);
FieldsMode_SetCondition(ref instance, ref setValue);
return(setValue);
},
// Invoke Setter
(instance, setValue) => { instance.FieldsMode = setValue; },
// Validate Set Operation
(instance, setValue) => { },
// Invoke Getter
instance => { return(instance.FieldsMode); },
// Validate Get Operation
(instance, setValue, getValue) => { });
}
static partial void InstanceFactory(ref WorkItemImpl instance, string callerName)
{
if (callerName == "Revisions_UnitTest")
{
instance = JsonWorkItem.APIFactory().GetWorkItem(95, WorkItemImpl.FromToken).Result;
}
}
private static LinkCollectionImpl ParseLinks(JsonWorkItem workItem)
{
var value = (JArray)((JObject)workItem.JsonValue).Properties().First(p => p.Name == "relations").Value;
LinkCollectionImpl results = LinkCollectionImpl.FromToken(value);
return(results);
}
private static FieldCollectionImpl ParseFields(JsonWorkItem workItem)
{
JProperty fieldsProperty = ((JObject)workItem.JsonValue).Properties().First(p => p.Name == "fields");
JToken fieldsValues = fieldsProperty.Value;
FieldCollectionImpl fields = FieldCollectionImpl.FromToken(fieldsValues);
return(fields);
}
/// <summary>
/// Updates the work item_ pre condition.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="workItem">The work item.</param>
partial void UpdateWorkItem_PreCondition(JsonWitAPI instance, ref JsonWorkItem workItem)
{
var workItems = instance.GetWorkItems(new List <int> {
2
}).Result;
workItem = workItems[0];
}
internal static JsonWorkItem GetInstance([CallerMemberName] string callerName = "")
{
JToken json = new JObject();
JsonSource(ref json);
JsonWorkItem instance = JsonWorkItem.FromToken(json);
InstanceFactory(ref instance, callerName);
return(instance);
}
/// <summary>
/// Gets the test instance.
/// </summary>
/// <returns>IWorkItemCollection.</returns>
private IWorkItemCollection GetTestInstance()
{
var initialItems = new List <WorkItemImpl>();
initialItems.Add(JsonWorkItem.APIFactory().GetWorkItem(195, WorkItemImpl.FromToken).Result);
var instance = new WorkItemCollectionImpl(null, initialItems);
Assert.IsNotNull(instance);
return(instance);
}
public void BuildWorkItem_UnitTest()
{
JsonWitAPI api = APIFactory.JsonWorkItemAPI;
var fieldValues = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("System.Title", "Sample Title"),
};
JsonWorkItem workItem = JsonWitAPI.BuildWorkItem("RestPlaypen", "Task", fieldValues);
Assert.IsNotNull(workItem);
}
/// <summary>
/// Gets the definition.
/// </summary>
/// <param name="referenceName">Name of the reference.</param>
/// <returns>JsonFieldDefinition.</returns>
public static JsonFieldDefinition GetDefinition(string referenceName)
{
if (s_Cache == null)
{
IReadOnlyList <JsonFieldDefinition> definitions = JsonWorkItem.APIFactory().GetFieldDefinitions().Result;
s_Cache = new Dictionary <string, JsonFieldDefinition>();
foreach (var definition in definitions)
{
s_Cache.Add(definition.ReferenceName, definition);
}
}
return(s_Cache[referenceName]);
}
public void UpdateWorkItem_UnitTest()
{
JsonWorkItem workItem = default(JsonWorkItem);
Task <JsonWorkItem> _retVal = default(Task <JsonWorkItem>);
ExecuteMethod(
() => { return(GetInstance()); },
instance =>
{
workItem = default(JsonWorkItem); //No Constructor
UpdateWorkItem_PreCondition(instance, ref workItem);
},
instance => { return(_retVal = instance.UpdateWorkItem(workItem)); },
instance => { UpdateWorkItem_PostValidate(instance, workItem, _retVal); });
}
public void GetWorkItem_UnitTest()
{
Uri uri = default(Uri);
JsonWorkItem _retVal = default(JsonWorkItem);
ExecuteMethod(
() => { return(GetInstance()); },
instance =>
{
uri = default(Uri); //No Constructor
GetWorkItem_PreCondition(instance, ref uri);
},
instance => { return(_retVal = instance.GetWorkItem(uri)); },
instance => { GetWorkItem_PostValidate(instance, uri, _retVal); });
}
public void GetLinksForWorkItem_UnitTest()
{
JsonWorkItem workItem = default(JsonWorkItem);
Task <JsonLinkCollection> _retVal = default(Task <JsonLinkCollection>);
ExecuteMethod(
() => { return(GetInstance()); },
instance =>
{
workItem = default(JsonWorkItem); //No Constructor
GetLinksForWorkItem_PreCondition(instance, ref workItem);
},
instance => { return(_retVal = instance.GetLinksForWorkItemRevision(workItem)); },
instance => { GetLinksForWorkItem_PostValidate(instance, workItem, _retVal); });
}
public void FromToken_UnitTest()
{
JToken json = default(JToken);
JsonWorkItem _retVal = default(JsonWorkItem);
ExecuteMethod(
() => { return(GetInstance()); },
instance =>
{
json = default(JToken); //No Constructor
FromToken_PreCondition(instance, ref json);
},
instance => { return(_retVal = JsonWorkItem.FromToken(json)); },
instance => { FromToken_PostValidate(instance, json, _retVal); });
}
public void WorkItemTypeName_UnitTest()
{
ExecuteProperty(
() =>
// Create Test Instance
{
JsonWorkItem instance = GetInstance();
return(instance);
},
null, null, null, // No Set Accessor
// Invoke Getter
instance => { return(instance.WorkItemTypeName); },
// Validate Get Operation
(instance, setValue, getValue) => { });
}
public async Task <JsonWorkItem> UpdateWorkItem(JsonWorkItem workItem)
{
JArray elements = JsonWorkItem.FieldsToJArray(workItem);
string body = ToJsonString(elements);
var exchange = StructuredHttpExchange.Patch(WitRestCalls.WorkItem, body);
exchange.SetRoute("{id}", workItem.Id);
JsonWorkItem result = await ProcessCollectionRequest(exchange, jObject =>
{
JsonWorkItem newWorkItem = JsonWorkItem.FromToken(jObject);
return(newWorkItem);
});
return(result);
}
public void FieldsToJArray_UnitTest()
{
JsonWorkItem workItem = default(JsonWorkItem);
JArray _retVal = default(JArray);
ExecuteMethod(
() => { return(GetInstance()); },
instance =>
{
workItem = default(JsonWorkItem); //No Constructor
FieldsToJArray_PreCondition(instance, ref workItem);
},
instance => { return(_retVal = JsonWorkItem.FieldsToJArray(workItem)); },
instance => { FieldsToJArray_PostValidate(instance, workItem, _retVal); });
}
public static TWorkItem BuildWorkItem <TWorkItem>(string projectName, string workItemTypeName, IReadOnlyList <KeyValuePair <string, object> > fieldValues, Func <JToken, TWorkItem> fromToken) where TWorkItem : JsonWorkItem
{
Task <IReadOnlyDictionary <string, JsonWorkItemType> > workItemTypes = JsonWorkItem.APIFactory().GetWorkItemTypes(projectName);
JsonWorkItemType workItemType = workItemTypes.Result[workItemTypeName];
JsonFieldDefinitionCollection definitions = workItemType.FieldDefinitions;
var json = new JObject();
json.Add(new JProperty("id", "-1"));
json.Add(new JProperty("rev", "-1"));
json.Add(new JProperty("url", "http://example.com"));
var jFieldContainer = new JObject();
var jFieldsProperty = new JProperty("fields", jFieldContainer);
foreach (JsonFieldDefinition fieldDefinition in definitions)
{
object content = null;
switch (fieldDefinition.ReferenceName)
{
case "System.TeamProject":
content = projectName;
break;
case "System.WorkItemType":
content = workItemTypeName;
break;
case "System.Id":
content = -1;
break;
case "System.Rev":
content = -1;
break;
}
var jProperty = new JProperty(fieldDefinition.ReferenceName, content);
jFieldContainer.Add(jProperty);
}
json.Add(jFieldsProperty);
TWorkItem retVal = fromToken(json);
foreach (KeyValuePair <string, object> field in fieldValues)
{
retVal.SetFieldValue(field.Key, field.Value);
}
return(retVal);
}
public void CreateWorkItem_UnitTest()
{
JsonWitAPI api = APIFactory.JsonWorkItemAPI;
const string project = "RestPlaypen";
const string workItemType = "Task";
var fieldValues = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("System.Title", "WorkItem Created by Unit Testing")
// new KeyValuePair<string, object>("System.Project", "RestPlaypen"),
// new KeyValuePair<string, object>("System.WorkItemType", "Task")
};
JsonWorkItem workItem = JsonWitAPI.BuildWorkItem(project, workItemType, fieldValues);
Task <JsonWorkItem> createTask = api.CreateWorkItem(project, workItemType, workItem, false);
JsonWorkItem finalResult = createTask.Result;
Assert.IsNotNull(finalResult);
}
/// <summary>
/// Froms the token.
/// </summary>
/// <param name="json">The json.</param>
/// <returns>JsonRelatedLink.</returns>
public new static JsonRelatedLink FromToken(JToken json)
{
var initializer = new JsonWorkItemInitializer
{
OtherItemInitializer = new ParameterizedLazyWithReset <JsonRelatedLink, WorkItemImpl>(o =>
{
WorkItemImpl retVal = JsonWorkItem.APIFactory().GetWorkItem(new Uri(sr_Url.Eval(o)), WorkItemImpl.FromToken);
return(retVal);
}),
LinkTypeEndInitializer = new ParameterizedLazyWithReset <JsonRelatedLink, WorkItemLinkTypeEndImpl>(o =>
{
JProperty property = ((JObject)o.JsonValue).Properties().FirstOrDefault(p => p.Name == "rel");
var retVal = new WorkItemLinkTypeEndImpl(property.Value);
return(retVal);
})
};
return(new RelatedLinkImpl(json, initializer));
}
public void BuildWorkItem_UnitTest()
{
String projectName = default(String);
String workItemTypeName = default(String);
IReadOnlyList <KeyValuePair <String, Object> > fieldValues = default(IReadOnlyList <KeyValuePair <String, Object> >);
JsonWorkItem _retVal = default(JsonWorkItem);
ExecuteMethod(
() => { return(GetInstance()); },
instance =>
{
projectName = default(String); //No Constructor
workItemTypeName = default(String); //No Constructor
fieldValues = default(IReadOnlyList <KeyValuePair <String, Object> >); //No Constructor
BuildWorkItem_PreCondition(instance, ref projectName, ref workItemTypeName, ref fieldValues);
},
instance => { return(_retVal = JsonWitAPI.BuildWorkItem(projectName, workItemTypeName, fieldValues)); },
instance => { BuildWorkItem_PostValidate(instance, projectName, workItemTypeName, fieldValues, _retVal); });
}
/// <summary>
/// Creates the work item.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="workItemType">Type of the work item.</param>
/// <param name="workItem">The work item.</param>
/// <param name="inPlaceUpdate">if set to <c>true</c> [in place update].</param>
/// <returns>Task<JsonWorkItem>.</returns>
public async Task <JsonWorkItem> CreateWorkItem(string project, string workItemType, JsonWorkItem workItem, bool inPlaceUpdate)
{
JArray elements = JsonWorkItem.FieldsToJArray(workItem);
var body = ToJsonString(elements);
var exchange = StructuredHttpExchange.Patch(WitRestCalls.WorkItems1, body);
exchange.SetRoute("{type}", workItemType.Replace(" ", "%20"));
JsonWorkItem result = await ProcessProjectRequest(project, exchange, jObject =>
{
if (inPlaceUpdate)
{
workItem.CaptureJson(jObject);
return(workItem);
}
var newWorkItem = JsonWorkItem.FromToken(jObject);
return(newWorkItem);
});
return(result);
}
public void CreateWorkItem_UnitTest()
{
String project = default(String);
String workItemType = default(String);
JsonWorkItem workItem = default(JsonWorkItem);
Boolean inPlaceUpdate = default(Boolean);
Task <JsonWorkItem> _retVal = default(Task <JsonWorkItem>);
ExecuteMethod(
() => { return(GetInstance()); },
instance =>
{
project = default(String); //No Constructor
workItemType = default(String); //No Constructor
workItem = default(JsonWorkItem); //No Constructor
inPlaceUpdate = default(Boolean); //No Constructor
CreateWorkItem_PreCondition(instance, ref project, ref workItemType, ref workItem, ref inPlaceUpdate);
},
instance => { return(_retVal = instance.CreateWorkItem(project, workItemType, workItem, inPlaceUpdate)); },
instance => { CreateWorkItem_PostValidate(instance, project, workItemType, workItem, inPlaceUpdate, _retVal); });
}
/// <summary>
/// Creates the work item.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="workItem">The work item.</param>
/// <returns>Task<IWorkItem>.</returns>
/// <exception cref="ToBeImplementedException"></exception>
public Task <IWorkItem> CreateWorkItem(string project, IWorkItem workItem)
{
string workItemType = workItem.Type.Name;
var fieldValues = new List <KeyValuePair <string, object> >();
for (int index = 0; index < workItem.Fields.Count; ++index)
{
var item = workItem.Fields[index];
var fieldName = item.Name;
var fieldValue = item.Value;
fieldValues.Add(new KeyValuePair <string, object>(fieldName, fieldValue));
}
JsonWorkItem jWorkItem = JsonWitAPI.BuildWorkItem(project, workItemType, fieldValues);
var internalTask = r_JsonAPI.CreateWorkItem(project, workItemType, jWorkItem, true);
var result = new Task <IWorkItem>(() =>
{
internalTask.Wait();
// TODO Transfer State from jWorkItem to workItem;
return(workItem);
});
result.Start();
return(result);
}
partial void OtherWorkItem_SetCondition(ref JsonWorkItemLink instance, ref JsonWorkItem setValue);
/// <summary>
/// Gets the field type_ pre condition.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="fieldName">Name of the field.</param>
partial void GetFieldType_PreCondition(JsonWorkItem instance, ref String fieldName)
{
fieldName = "System.Title";
}
/// <summary>
/// Froms the token_ pre condition.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="json">The json.</param>
partial void FromToken_PreCondition(JsonWorkItem instance, ref JToken json)
{
json = JObject.Parse(CannedMessages.JsonWorkItem324);
}
/// <summary>
/// Fieldses to j array_ pre condition.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="workItem">The work item.</param>
partial void FieldsToJArray_PreCondition(JsonWorkItem instance, ref JsonWorkItem workItem)
{
workItem = GetInstance();
}
partial void WorkItemTypeName_SetCondition(ref JsonWorkItem instance, ref String setValue);
private static LinkCollectionImpl DeferredLoadLinks(JsonWorkItem workItem)
{
LinkCollectionImpl result = APIFactory().GetLinksForWorkItemRevision(workItem, LinkCollectionImpl.FromToken).Result;
return(result);
}
private static FieldCollectionImpl DeferredLoadFields(JsonWorkItem workItem)
{
throw new NotImplementedException();
}
