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(); }