Пример #1
0
        public override void Given()
        {
            var workItems = new List <IWorkItem>
            {
                new MockWorkItem("SimpleMockWorkItem", new Dictionary <string, object>
                {
                    { "ID", 1 },
                    { "IntField", 2 }
                }),
                new MockWorkItem("SimpleMockWorkItem", new Dictionary <string, object>
                {
                    { "ID", 2 },
                    { "IntField", 4 }
                })
                ,
                new MockWorkItem("SimpleMockWorkItem", new Dictionary <string, object>
                {
                    { "ID", 3 },
                    { "IntField", 3 }
                })
                ,
                new MockWorkItem("SimpleMockWorkItem", new Dictionary <string, object>
                {
                    { "ID", 4 },
                    { "IntField", 4 }
                })
                ,
                new MockWorkItem("SimpleMockWorkItem", new Dictionary <string, object>
                {
                    { "ID", 5 },
                    { "IntField", 5 }
                })
            };

            var links = new[] {
                new MockWorkItemLinkInfo(0, 3),
                new MockWorkItemLinkInfo(3, 1),
                new MockWorkItemLinkInfo(3, 2),
                new MockWorkItemLinkInfo(0, 4),
                new MockWorkItemLinkInfo(0, 5)
            };

            WorkItemStore = new MockWorkItemStore(workItems, links);
            FieldMapper   = new CachingFieldMapper(new FieldMapper());

            var propertyInspector = new PropertyInspector(PropertyReflector);
            var mapperStrategies  = new IWorkItemMapperStrategy[]
            {
                new AttributeMapperStrategy(propertyInspector,
                                            new TypeParser()),
                new WorkItemLinksMapperStrategy(propertyInspector, WorkItemStore)
            };

            Builder = new WiqlQueryBuilder(new WiqlTranslator(FieldMapper), new PartialEvaluator(), new QueryRewriter());
            Mapper  = new WorkItemMapper(mapperStrategies);
        }
Пример #2
0
        public override void Given()
        {
            var propertyInspector = new PropertyInspector(new PropertyReflector());
            var mappingStrategies = new IWorkItemMapperStrategy[]
            {
                new AttributeMapperStrategy(propertyInspector),
                new WorkItemLinksMapperStrategy(propertyInspector, WorkItemStore)
            };

            WorkItemMapper = new WorkItemMapper(mappingStrategies);
        }
Пример #3
0
        protected WorkItemMapper CreateNoExceptionMapper()
        {
            var propertyInspector = new PropertyInspector(new PropertyReflector());
            var mappingStrategies = new IWorkItemMapperStrategy[]
            {
                new NoExceptionAttributeMapperStrategy(propertyInspector),
                new WorkItemLinksMapperStrategy(propertyInspector, WorkItemStore)
            };

            return(new WorkItemMapper(mappingStrategies));
        }
Пример #4
0
            public void SetupData()
            {
                var propertyInspector = new PropertyInspector(new PropertyReflector());
                var typeParser        = new TypeParser();
                var mappingStrategies = new IWorkItemMapperStrategy[]
                { new AttributeMapperStrategy(propertyInspector, typeParser) };

                _mapper = new WorkItemMapper(mappingStrategies);

                var generator = new WorkItemGenerator <MockWorkItem>(() => new MockWorkItem("Baz"), new[] { "Revisions", "Item" });

                _items = generator.Generate();
            }
Пример #5
0
            public void SetupData()
            {
                var propertyInspector = new PropertyInspector(new PropertyReflector());

                _strategy = new BulkIdentityAwareAttributeMapperStrategy(
                    propertyInspector,
                    new MockIdentityManagementService()
                    );

                var wis       = new MockWorkItemStore();
                var generator = new WorkItemGenerator <MockWorkItem>(() => wis.Create(), new[] { "Revisions", "Item" });

                wis.Add(generator.Generate());

                _workItemMappings = generator.Items.ToDictionary(k => (IWorkItem)k, e => (IIdentifiable <int?>) new MockIdentityType());
            }
Пример #6
0
            public void SetupData()
            {
                var generator = new WorkItemLinkGenerator(() => new MockWorkItem("Baz"), new[] { "Revisions", "Item" });

                _items = generator.Generate();
                var propertyInspector = new PropertyInspector(new PropertyReflector());
                var typeParser        = new TypeParser();
                var mappingStrategies = new IWorkItemMapperStrategy[]
                {
                    new AttributeMapperStrategy(propertyInspector, typeParser),
                    new WorkItemLinksMapperStrategy(propertyInspector, new MockWorkItemStore(_items)),
                };

                Mapper       = new WorkItemMapper(mappingStrategies);
                MappingItems = _items.Take(500).ToList();
            }
Пример #7
0
            public void SetupData()
            {
                var propertyInspector = new PropertyInspector(new PropertyReflector());
                var mappingStrategies = new IWorkItemMapperStrategy[]
                { new AttributeMapperStrategy(propertyInspector) };

                _mapper = new WorkItemMapper(mappingStrategies);

                var wis       = new MockWorkItemStore();
                var generator = new WorkItemGenerator <MockWorkItem>(() => wis.Create(), new[] { "Revisions", "Item" });

                _items = generator.Generate(1);
                wis.Add(_items);

                _item = new[] { _items.First() };
                _type = typeof(MockModel);
            }
Пример #8
0
        public override void Given()
        {
            var workItemStore     = new MockWorkItemStore(WorkItemStoreWorkItems, WorkItemStoreWorkItemLinks);
            var fieldMapper       = new CachingFieldMapper(new FieldMapper());
            var propertyReflector = new PropertyReflector();
            var propertyInspector = new PropertyInspector(propertyReflector);
            var builder           = new WiqlQueryBuilder(new RelativesAwareWiqlTranslator(fieldMapper), new PartialEvaluator(), new RelativesAwareQueryRewriter());
            var mapperStrategies  = new IWorkItemMapperStrategy[]
            {
                new AttributeMapperStrategy(propertyInspector,
                                            new TypeParser()),
                new WorkItemLinksMapperStrategy(propertyInspector, workItemStore),
                new ParentIdMapperStrategy(workItemStore)
            };
            var mapper        = new WorkItemMapper(mapperStrategies);
            var queryProvider = new RelativesAwareTeamFoundationServerWorkItemQueryProvider(workItemStore, builder, mapper, fieldMapper);

            Query = new Query <SimpleMockModel>(queryProvider, builder);
        }
        public override void Given()
        {
            var propertyInspector = new PropertyInspector(new PropertyReflector());

            _strategy = new BulkIdentityAwareAttributeMapperStrategy(
                propertyInspector,
                Identities == null
                                ? new MockIdentityManagementService()
                                : new MockIdentityManagementService(Identities));
            var sourceWorkItems = new[]
            {
                new MockWorkItem(new Dictionary <string, object>
                {
                    { MockIdentityType.BackingField, IdentityFieldBackingValue }
                })
            };

            _workItemMappings = sourceWorkItems.Select(t => new KeyValuePair <IWorkItem, IIdentifiable>(t, new MockIdentityType())).ToList();
        }
Пример #10
0
        public override void Given()
        {
            var workItemStore = CreateWorkItemStore();
            var fieldMapper   = CreateFieldMapper();

            var propertyInspector = CreatePropertyInspector();

            var mapperStrategies = new IWorkItemMapperStrategy[]
            {
                new AttributeMapperStrategy(propertyInspector),
                new WorkItemLinksMapperStrategy(propertyInspector, workItemStore)
            };

            var builder = new WiqlQueryBuilder(new WiqlTranslator(fieldMapper), new PartialEvaluator(), new QueryRewriter());
            var mapper  = new WorkItemMapper(mapperStrategies);

            var queryProvider = new MapperTeamFoundationServerWorkItemQueryProvider(workItemStore, builder, mapper);

            Query = new Query <T>(queryProvider, builder);
        }
        public override void Given()
        {
            var propertyInspector = new PropertyInspector(new PropertyReflector());

            _strategy = new BulkIdentityAwareAttributeMapperStrategy(
                propertyInspector,
                Identities == null
                                ? new MockIdentityManagementService()
                                : new MockIdentityManagementService(Identities));
            var sourceWorkItems = new[]
            {
                new MockWorkItem(
                    new MockWorkItemType("Baz", MockIdentityType.BackingField),
                    new Dictionary <string, object>
                {
                    { MockIdentityType.BackingField, IdentityFieldBackingValue }
                })
            };

            _workItemMappings = sourceWorkItems.ToDictionary(k => (IWorkItem)k, e => (IIdentifiable <int?>) new MockIdentityType());
        }
        public void Setup()
        {
            var propertyInspector = new PropertyInspector(new PropertyReflector());

            _strategy = new BulkIdentityAwareAttributeMapperStrategy(
                propertyInspector,
                new MockIdentityManagementService()
                );

            var generator = new WorkItemGenerator <MockWorkItem>(() => new MockWorkItem(), new[] { "Revisions", "Item", "AssignedTo" });

            generator.Generate();

            var assignees = new[]
            {
                MockIdentityManagementService.Danj.DisplayName,
                MockIdentityManagementService.Adamb.DisplayName,
                MockIdentityManagementService.Chrisj.DisplayName,
                MockIdentityManagementService.Chrisjoh.DisplayName,
                MockIdentityManagementService.Chrisjohn.DisplayName,
                MockIdentityManagementService.Chrisjohns.DisplayName
            };

            var sourceWorkItems = generator
                                  .Items
                                  // Run post-randomization to enable our scenario
                                  .Select(
                s =>
            {
                var i = Randomizer.Instance.Next(0, assignees.Length - 1);
                s[MockIdentityType.BackingField] = assignees[i];

                return(s);
            });

            _workItemMappings = sourceWorkItems.Select(t => new KeyValuePair <IWorkItem, IIdentifiable>(t, new MockIdentityType())).ToList();
        }
Пример #13
0
            public void SetupData()
            {
                var wis       = new MockWorkItemStore();
                var generator = new WorkItemLinkGenerator <MockWorkItem>(
                    () => wis.Create(),
                    wis.WorkItemLinkTypes[CoreLinkTypeReferenceNames.Hierarchy],
                    (e, s, t) => new MockRelatedLink(e, s, t),
                    new[] { "Revisions", "Item" });

                wis.Add(generator.Generate());
                var propertyInspector = new PropertyInspector(new PropertyReflector());
                var mappingStrategies = new IWorkItemMapperStrategy[]
                {
                    new AttributeMapperStrategy(propertyInspector),
                    new WorkItemLinksMapperStrategy(propertyInspector, wis),
                };

                _mapper = new WorkItemMapper(mappingStrategies);

                // Try to map 10% of what came back
                var mapCount = (int)(generator.Items.Count * 0.1);

                _items = generator.Items.Take(mapCount).ToList();
            }