private InMemoryWorkItemEndpoint CreateAndConfigureInMemoryWorkItemEndpoint(int workItemCount)
        {
            InMemoryWorkItemEndpoint e = CreateInMemoryWorkItemEndpoint();

            AddWorkItems(e, workItemCount);
            return(e);
        }
Example #2
0
        private InMemoryWorkItemEndpoint CreateAndConfigureInMemoryWorkItemEndpoint(EndpointDirection direction, int workItemCount)
        {
            InMemoryWorkItemEndpoint e = CreateInMemoryWorkItemEndpoint(direction);

            AddWorkItems(e, workItemCount);
            return(e);
        }
Example #3
0
        private void AddWorkItems(InMemoryWorkItemEndpoint e, int workItemCount)
        {
            var list = new List <WorkItemData>();

            for (int i = 0; i < workItemCount; i++)
            {
                e.PersistWorkItem(new WorkItemData()
                {
                    Id        = i.ToString(),
                    Revisions = GetRevisions()
                });
            }

            List <RevisionItem> GetRevisions()
            {
                Random rand              = new Random();
                int    revCount          = rand.Next(0, 5);
                List <RevisionItem> list = new List <RevisionItem>();

                for (int i = 0; i < revCount; i++)
                {
                    list.Add(new RevisionItem {
                        Index = i, Number = i, ChangedDate = DateTime.Now.AddHours(-i)
                    });
                }
                return(list);
            }
        }
Example #4
0
        public void FilterHalfTest()
        {
            InMemoryWorkItemEndpoint e1 = CreateAndConfigureInMemoryWorkItemEndpoint(EndpointDirection.Source, 20);
            InMemoryWorkItemEndpoint e2 = CreateAndConfigureInMemoryWorkItemEndpoint(EndpointDirection.Target, 10);

            e1.Filter(e2.GetWorkItems());
            Assert.AreEqual(10, e1.Count);
        }
        private InMemoryWorkItemEndpoint CreateInMemoryWorkItemEndpoint()
        {
            var options = new InMemoryWorkItemEndpointOptions();
            InMemoryWorkItemEndpoint e = Services.GetRequiredService <InMemoryWorkItemEndpoint>();

            e.Configure(options);
            return(e);
        }
        public void FilterHalfTest()
        {
            InMemoryWorkItemEndpoint e1 = CreateAndConfigureInMemoryWorkItemEndpoint(20);
            InMemoryWorkItemEndpoint e2 = CreateAndConfigureInMemoryWorkItemEndpoint(10);

            e1.Filter(e2.GetWorkItems());
            Assert.AreEqual(10, e1.Count);
        }
        public void EmptyTest()
        {
            var targetOptions          = new InMemoryWorkItemEndpointOptions();
            InMemoryWorkItemEndpoint e = Services.GetRequiredService <InMemoryWorkItemEndpoint>();

            e.Configure(targetOptions);
            Assert.AreEqual(0, e.Count);
        }
        private static InMemoryWorkItemEndpoint CreateAndConfigureInMemoryWorkItemEndpoint(EndpointDirection direction, string queryString)
        {
            InMemoryWorkItemEndpoint e     = CreateInMemoryWorkItemEndpoint(EndpointDirection.Source);
            InMemoryWorkItemQuery    query = new InMemoryWorkItemQuery();

            query.Configure(null, queryString, null);
            e.Configure(query, null);
            return(e);
        }
        private static InMemoryWorkItemEndpoint CreateInMemoryWorkItemEndpoint(EndpointDirection direction)
        {
            var options = Options.Create <InMemoryWorkItemEndpointOptions>(new InMemoryWorkItemEndpointOptions()
            {
                Direction = direction
            });
            InMemoryWorkItemEndpoint e = new InMemoryWorkItemEndpoint(options);

            return(e);
        }
        public void EmptyTest()
        {
            var targetOptions = Options.Create <InMemoryWorkItemEndpointOptions>(new InMemoryWorkItemEndpointOptions()
            {
                Direction = EndpointDirection.Source
            });
            InMemoryWorkItemEndpoint e = new InMemoryWorkItemEndpoint(targetOptions);

            Assert.AreEqual(0, e.Count);
        }
Example #11
0
        public void PersistWorkItemExistsTest()
        {
            InMemoryWorkItemEndpoint e1 = CreateAndConfigureInMemoryWorkItemEndpoint(EndpointDirection.Source, 20);
            InMemoryWorkItemEndpoint e2 = CreateAndConfigureInMemoryWorkItemEndpoint(EndpointDirection.Target, 10);

            foreach (WorkItemData item in e1.GetWorkItems())
            {
                e2.PersistWorkItem(item);
            }
            Assert.AreEqual(20, e2.Count);
        }
        public void PersistWorkItemWithFilterTest()
        {
            InMemoryWorkItemEndpoint e1 = CreateAndConfigureInMemoryWorkItemEndpoint(EndpointDirection.Source, "20");
            InMemoryWorkItemEndpoint e2 = CreateAndConfigureInMemoryWorkItemEndpoint(EndpointDirection.Target, "10");

            e1.Filter(e2.GetWorkItems());
            Assert.AreEqual(10, e1.Count);
            foreach (WorkItemData item in e1.GetWorkItems())
            {
                e2.PersistWorkItem(item);
            }
            Assert.AreEqual(20, e2.Count);
        }
Example #13
0
        public void ConfiguredTest()
        {
            InMemoryWorkItemEndpoint e = CreateAndConfigureInMemoryWorkItemEndpoint(EndpointDirection.Source, 10);

            Assert.AreEqual(10, e.Count);
        }