Example #1
0
        public async Task Should_resolve_schema_by_id()
        {
            var schema = SetupSchema(0, false);

            var actual = await sut.GetSchemaAsync(appId.Id, schema.Id);

            Assert.Same(actual, schema);
        }
Example #2
0
        public async Task Should_resolve_schema_by_name()
        {
            var(expected, _) = SetupSchema();

            A.CallTo(() => cache.GetSchemaIdAsync(schemaId.Name))
            .Returns(schemaId.Id);

            var actual1 = await sut.GetSchemaAsync(appId.Id, schemaId.Name, false);

            var actual2 = await sut.GetSchemaAsync(appId.Id, schemaId.Name, false);

            Assert.Same(expected, actual1);
            Assert.Same(expected, actual2);

            A.CallTo(() => grainFactory.GetGrain <ISchemaGrain>(A <string> ._, null))
            .MustHaveHappenedTwiceExactly();

            A.CallTo(() => cache.GetSchemaIdAsync(A <string> ._))
            .MustHaveHappenedTwiceExactly();
        }
Example #3
0
        public async Task Should_resolve_schema_by_name_and_id_if_cached_before()
        {
            var expected = SetupSchema();

            A.CallTo(() => index.GetIdAsync(schemaId.Name))
            .Returns(schemaId.Id);

            var actual1 = await sut.GetSchemaByNameAsync(appId.Id, schemaId.Name, true);

            var actual2 = await sut.GetSchemaByNameAsync(appId.Id, schemaId.Name, true);

            var actual3 = await sut.GetSchemaAsync(appId.Id, schemaId.Id, true);

            Assert.Same(expected, actual1);
            Assert.Same(expected, actual2);
            Assert.Same(expected, actual3);

            A.CallTo(() => grainFactory.GetGrain <ISchemaGrain>(A <string> ._, null))
            .MustHaveHappenedOnceExactly();

            A.CallTo(() => index.GetIdAsync(A <string> ._))
            .MustHaveHappenedOnceExactly();
        }