Example #1
0
        public async Task Dataset_InMemoryCRUD()
        {
            var id             = "ANewId";
            var logger         = (TestLogger)Resolve <ILogger>();
            var datasetService = Resolve <IDatasetService>();
            var createHandler  = Resolve <ICreateDatasetHandler>();
            var readHandler    = Resolve <IReadDatasetHandler>();
            var updateHandler  = Resolve <IUpdateDatasetHandler>();
            var deleteHandler  = Resolve <IDeleteDatasetHandler>();

            // create
            var createVerb = new CreateDatasetVerb();

            createVerb.Id = id;
            createHandler.Handle(createVerb).Wait();
            var ds = await datasetService.Get <EmptyDataset>(id);

            Assert.IsNotNull(ds);
            Assert.AreEqual(ds.Id, id);
            Assert.AreEqual(ds.Type.Value, DatasetTypes.Empty.Value);

            // update inline
            var updateVerb = new UpdateDatasetVerb();

            updateVerb.Id    = id;
            updateVerb.Label = "ALabel";
            updateVerb.Type  = DatasetTypes.SingleClassImage.Value;
            updateVerb.Url   = "http://example.com/pcture.jpeg";
            updateHandler.Handle(updateVerb).Wait();
            var singleClassDs = await datasetService.Get <SingleClassImageDataset>(id);

            Assert.IsNotNull(singleClassDs);
            Assert.AreEqual(singleClassDs.Id, id);
            Assert.AreEqual(singleClassDs.Type.Value, DatasetTypes.SingleClassImage.Value);

            // read the data
            var readVerb = new ReadDatasetVerb();

            readVerb.Id = id;
            readHandler.Handle(readVerb).Wait();
            Assert.IsTrue(logger.Messages.Any(m => m.Contains($"{id} is of type {DatasetTypes.SingleClassImage.Value}")));
            Assert.IsTrue(logger.Messages.Any(m => m.Contains($"1")));

            // delete the dataset
            var deleteVerb = new DeleteDatasetVerb();

            deleteVerb.Id = createVerb.Id;

            deleteHandler.Handle(deleteVerb).Wait();

            await Assert.ThrowsExceptionAsync <DatasetNotFoundException>(() => datasetService.Get <EmptyDataset>(createVerb.Id));
        }
        public async Task Handle(UpdateDatasetVerb verb)
        {
            IDataset emptySet;

            try
            {
                emptySet = await datasetService.Get <EmptyDataset>(verb.Id);
            }
            catch (FileNotFoundException)
            {
                logger.Error(null, new FileNotFoundException($"Dataset does not exist. Please use 'create-dataset --id {verb.Id}' before using 'update-dataset'."));
                return;
            }

            emptySet.Type = DatasetTypes.FromValue(verb.Type);

            if (verb.Replace)
            {
                await datasetService.Set(emptySet);
            }

            if (string.Equals(DatasetTypes.SingleClassImage.Value, verb.Type))
            {
                // will have to branch here in future based on different types of sets
                var dataset = await resolverService.ResolveSingleClassImage(emptySet);

                if (StringExists(verb.FromFile) && StringExists(verb.Label))
                {
                    // either this is an empty set, or the set exists and the user has chosen the right type
                    // depending on the type, we load the dataset
                    logger.Log($"Updating dataset {verb.Id} with file {verb.FromFile} and label {verb.Label}");
                    var urls = fileParser.LinesFromFile(verb.FromFile);
                    foreach (var url in urls)
                    {
                        logger.Log($"adding {url}");
                        // add the urls
                        dataset.AddLabelledImage(verb.Label, url);
                    }

                    await datasetService.Set(dataset);
                }
                else if (StringExists(verb.Url) && StringExists(verb.Label))
                {
                    if (!DatasetTypes.IsValid(verb.Type))
                    {
                        logger.Log($"{verb.Type} is an invalid dataset type");
                        logger.Log($"Available types are {DatasetTypes.PrintTypes()}");
                        return;
                    }
                    dataset.Type = DatasetTypes.FromValue(verb.Type);
                    logger.Log($"Adding url {verb.Url} as {verb.Label}");
                    dataset.AddLabelledImage(verb.Label, verb.Url);
                    await datasetService.Set(dataset);
                }
            }
            else if (string.Equals(verb.Type, DatasetTypes.Empty.Value))
            {
                logger.Log($"Dataset is still typed as Empty. Use --type");
            }
            else
            {
                logger.Log($"Unknown type {verb.Type}");
            }
        }