Ejemplo n.º 1
0
        public async Task <IActionResult> Post([FromBody] AtomCreationRequest request)
        {
            if (request == null)
            {
                return(BadRequest("Invalid atom creation request format"));
            }

            try
            {
                var atomId = new AtomId(request.Kind, request.Name, request.Version);
                var realId = await _storage.AddAsync(atomId,
                                                     request
                                                     .Dependencies
                                                     .Select(dep => new AtomId(dep.Kind, dep.Name, dep.Version)),
                                                     Convert.FromBase64String(request.Content ?? string.Empty));

                return(Ok(realId));
            }
            catch (ArgumentException e)
            {
                return(NotFound(e.Message));
            }
            catch (FormatException e)
            {
                return(BadRequest(e.Message));
            }
        }
Ejemplo n.º 2
0
        public async Task AtomCreation_CreateAtomNoDeps_AtomWithNoDepsCreated()
        {
            // Given
            var context = InitContext();

            var contentString = "Hello, world!";
            var content       = Encoding.UTF8.GetBytes(contentString);

            var atomId = new AtomId("PlainText", "Hello", "1.0.1");

            // When
            using (var storage = new AtomStorage(context))
            {
                await storage.AddAsync(atomId, Enumerable.Empty <AtomId>(), content);
            }

            // Then
            using (context = new InMemoryResolverContext())
            {
                var dbAtom = context.Atoms.Include(a => a.Content)
                             .Include(a => a.Dependencies)
                             .ThenInclude(dep => dep.Dependency)
                             .Single(a => a.Kind == atomId.Kind &&
                                     a.Name == atomId.Name &&
                                     a.Version == atomId.Version);

                Assert.Empty(dbAtom.Dependencies);
                var actualContentString = Encoding.UTF8.GetString(dbAtom.Content.Content);

                Assert.Equal(contentString, actualContentString);
            }
        }
Ejemplo n.º 3
0
        public async Task VersionWildcard_CreateAtomWithoutPredcessors_CreatedAtomWithDefaultVersion()
        {
            // Given
            var context = InitContext();

            var contentString = "Hello, world!";
            var content       = Encoding.UTF8.GetBytes(contentString);

            var atomId = new AtomId("PlainText", "Hello");

            // When
            using (var storage = new AtomStorage(context))
            {
                await storage.AddAsync(atomId, Enumerable.Empty <AtomId>(), content);
            }

            // Then
            using (context = new InMemoryResolverContext())
            {
                var dbAtom = context.Atoms.Single(a => a.Kind == atomId.Kind &&
                                                  a.Name == atomId.Name);

                Assert.Equal(AtomId.DefaultVersion, dbAtom.Version);
            }
        }
Ejemplo n.º 4
0
        public async Task DependecyResolutionOrdering_MultipleAtomsDependent_CorrectOrderReturned()
        {
            var storage = new AtomStorage(InitContext());

            var si = await storage.AddAsync(new AtomId("fsdecl", "SI"),
                                            Enumerable.Empty <AtomId>(),
                                            new byte[0]);

            var eeg = await storage.AddAsync(new AtomId("fsdecl", "Eeg"),
                                             Enumerable.Empty <AtomId>().Append(si),
                                             new byte[0]);

            var resolver = new Resolver.Endpoint.Resolver(storage);
            var resolved = await resolver.ResolveAsync(new [] { new AtomId("fsdecl", "Eeg"), new AtomId("fsdecl", "SI") });

            Assert.Equal(new [] { si, eeg }, resolved);
        }
Ejemplo n.º 5
0
        public async Task DependecyResolutionOrdering_SingleAtomDuplicateDeps_CorrectOrderReturned()
        {
            var storage = new AtomStorage(InitContext());
            var si      = await storage.AddAsync(new AtomId("fsdecl", "SI"),
                                                 Enumerable.Empty <AtomId>(),
                                                 new byte[0]);

            var eeg = await storage.AddAsync(new AtomId("fsdecl", "Eeg"),
                                             Enumerable.Empty <AtomId>().Append(si),
                                             new byte[0]);

            var workflow = await storage.AddAsync(new AtomId("filomena", "IcaFiltering"),
                                                  Enumerable.Empty <AtomId>().Append(eeg).Append(si),
                                                  new byte[0]);

            var resolver = new Resolver.Endpoint.Resolver(storage);
            var resolved = await resolver.ResolveAsync(new [] { workflow });

            Assert.Equal(new [] { si, eeg, workflow }, resolved);
        }
Ejemplo n.º 6
0
        public async Task AtomCreation_CreateAtomWithDeps_AtomWithDepsCreated()
        {
            // Given
            var context = InitContext();

            var contentString = "Hello, world!";
            var content       = Encoding.UTF8.GetBytes(contentString);

            var dependency = new AtomId("PlainText", "Hello", "1.0.1");
            var dependent  = new AtomId("Sentence", "World", "1.0.0");

            var dbAtomDep = new Atom
            {
                Kind    = dependency.Kind,
                Name    = dependency.Name,
                Version = dependency.Version
            };

            dbAtomDep.Content = new AtomContent
            {
                Atom    = dbAtomDep,
                Content = content
            };

            context.Atoms.Add(dbAtomDep);
            context.SaveChanges();

            // When
            using (var storage = new AtomStorage(context))
            {
                await storage.AddAsync(dependent,
                                       Enumerable.Empty <AtomId>().Append(dependency),
                                       content);
            }

            // Then
            using (context = new InMemoryResolverContext())
            {
                var dbAtom = context.Atoms.Include(a => a.Content)
                             .Include(a => a.Dependencies)
                             .ThenInclude(dep => dep.Dependency)
                             .Single(a => a.Kind == dependent.Kind &&
                                     a.Name == dependent.Name &&
                                     a.Version == dependent.Version);

                Assert.Single(dbAtom.Dependencies);

                var dependencyAtom = dbAtom.Dependencies.Single().Dependency;
                Assert.Equal(dbAtomDep.Kind, dependencyAtom.Kind);
                Assert.Equal(dbAtomDep.Name, dependencyAtom.Name);
                Assert.Equal(dbAtomDep.Version, dependencyAtom.Version);
            }
        }
Ejemplo n.º 7
0
        public async Task DependencyResolution_NotDependentAtomPassed_AtomOnlyReturned()
        {
            var storage = new AtomStorage(InitContext());
            var atomId  = await storage.AddAsync(new AtomId("text", "hello"), Enumerable.Empty <AtomId>(), new byte[0]);

            var resolver = new Resolver.Endpoint.Resolver(storage);
            var resolved = await resolver.ResolveAsync(new [] { atomId });

            Assert.Single(resolved);
            var resolvedId = resolved.Single();

            Assert.Equal(atomId, resolvedId);
        }
Ejemplo n.º 8
0
        public async Task VersionWildcard_CreateAtomWithPredcessor_CreatedAtomWithMinorIncremented(
            string predcessorVersion,
            string expectedVersion)
        {
            // Given
            var context = InitContext();

            var contentString = "Hello, world!";
            var content       = Encoding.UTF8.GetBytes(contentString);

            var atomId = new AtomId("PlainText", "Hello");

            var dbAtom = new Atom
            {
                Kind    = atomId.Kind,
                Name    = atomId.Name,
                Version = predcessorVersion
            };

            context.Atoms.Add(dbAtom);
            context.SaveChanges();

            // When
            using (var storage = new AtomStorage(context))
            {
                await storage.AddAsync(atomId, Enumerable.Empty <AtomId>(), content);
            }

            // Then
            using (context = new InMemoryResolverContext())
            {
                var addedAtom = context.Atoms.Single(a => a.Kind == atomId.Kind &&
                                                     a.Name == atomId.Name &&
                                                     a.Version != predcessorVersion);

                Assert.Equal(expectedVersion, addedAtom.Version);
            }
        }