public override async Task InitializeAsync()
        {
            var datasets = await Write.DataSets.RetrieveAsync(new[] { "test-dataset" }, true);

            if (!datasets.Any())
            {
                datasets = await Write.DataSets.CreateAsync(new[]
                {
                    new DataSetCreate
                    {
                        ExternalId = "test-dataset",
                        Name       = "test-dataset"
                    }
                });
            }
            var dataset = datasets.First();

            DataSetId = dataset.Id;

            var extid    = Guid.NewGuid().ToString();
            var testPipe = new ExtPipeCreate
            {
                DataSetId  = DataSetId,
                ExternalId = extid,
                Name       = "test extpipe"
            };
            var result = await Write.ExtPipes.CreateAsync(new[] { testPipe });

            TestPipeline = result.First();
        }
        public async Task CreateAndDeleteExtPipes()
        {
            // Arrange
            var extId  = Guid.NewGuid().ToString();
            var create = new ExtPipeCreate
            {
                Contacts = new[]
                {
                    new ExtPipeContact
                    {
                        Email            = "*****@*****.**",
                        Name             = "test",
                        Role             = "test",
                        SendNotification = false
                    }
                },
                DataSetId     = tester.DataSetId,
                Description   = "Test description",
                Documentation = "Test documentation",
                ExternalId    = extId,
                Metadata      = new Dictionary <string, string> {
                    { "testKey", "testValue" }
                },
                Name     = "test",
                Schedule = "On trigger",
                Source   = "Some source"
            };

            // Act
            var created = await tester.Write.ExtPipes.CreateAsync(new[] { create });

            await tester.Write.ExtPipes.DeleteAsync(new[] { extId });

            // Assert
            Assert.Single(created);
        }
        public async Task CreateUpdateDeleteExtPipes()
        {
            // Arrange
            var extId  = Guid.NewGuid().ToString();
            var create = new ExtPipeCreate
            {
                Contacts = new[]
                {
                    new ExtPipeContact
                    {
                        Email            = "*****@*****.**",
                        Name             = "test",
                        Role             = "test",
                        SendNotification = false
                    }
                },
                DataSetId     = tester.DataSetId,
                Description   = "Test description",
                Documentation = "Test documentation",
                ExternalId    = extId,
                Metadata      = new Dictionary <string, string> {
                    { "testKey", "testValue" }
                },
                Name     = "test",
                Schedule = "On trigger",
                Source   = "Some source"
            };
            var extId2 = Guid.NewGuid().ToString();
            var update = new ExtPipeUpdate
            {
                Contacts = new UpdateEnumerable <ExtPipeContact>(new[] { new ExtPipeContact
                                                                         {
                                                                             Email            = "*****@*****.**",
                                                                             Name             = "test2",
                                                                             Role             = "test2",
                                                                             SendNotification = false
                                                                         } }, new[] { create.Contacts.First() }),
                Description   = new Update <string>("Test description 2"),
                Documentation = new Update <string>("Test documentation 2"),
                ExternalId    = new Update <string>(extId2),
                Metadata      = new UpdateDictionary <string>(new Dictionary <string, string> {
                    { "testKey2", "testValue2" }
                },
                                                              new[] { "testKey" }),
                Name     = new Update <string>("test 2"),
                Schedule = new Update <string>("Continuous"),
                Source   = new Update <string>("Some other source")
            };

            // Act
            await tester.Write.ExtPipes.CreateAsync(new[] { create });

            var result = await tester.Write.ExtPipes.UpdateAsync(new[] { new UpdateItem <ExtPipeUpdate>(extId)
                                                                         {
                                                                             Update = update
                                                                         } });

            await tester.Write.ExtPipes.DeleteAsync(new ExtPipeDelete { Items = new[] { Identity.Create(extId2) } });

            // Assert
            Assert.Single(result);
            var pipe = result.First();

            Assert.Single(pipe.Metadata);
            Assert.Single(pipe.Contacts);
            Assert.Equal("Continuous", pipe.Schedule);
        }