Beispiel #1
0
    public async Task Should_Not_Be_Authorized_On_Given_Record()
    {
        var id     = new LaunchRecordId(new Guid("bad361de-a6d5-425a-9cf6-f9b2dd236be6"));
        var client = new LaunchRecordClient(Factory.CreateClient());
        await ServiceProvider.WithScoped <RocketDbContext>()
        .Invoke(
            async z =>
        {
            var faker  = new RocketFaker();
            var rocket = faker.Generate();
            var record = new LaunchRecordFaker(new[] { rocket }.ToList()).Generate();
            z.Add(rocket);
            record.Id = id;
            z.Add(record);

            await z.SaveChangesAsync();
            return(record.Id);
        }
            );


        Func <Task> action = () => client.DeleteLaunchRecordAsync(id.Value);
        await action.Should().ThrowAsync <ApiException <ProblemDetails> >()
        .Where(z => z.StatusCode == 403 && z.Result.Status == 403 && z.Result.Title == "Forbidden");
    }
Beispiel #2
0
    public async Task Should_Not_Be_Authorized_On_Given_Record()
    {
        var id = new LaunchRecordId(new Guid("bad361de-a6d5-425a-9cf6-f9b2dd236be6"));
        await ServiceProvider.WithScoped <RocketDbContext>()
        .Invoke(
            async z =>
        {
            var faker  = new RocketFaker();
            var rocket = faker.Generate();
            var record = new LaunchRecordFaker(new[] { rocket }.ToList()).Generate();
            z.Add(rocket);
            record.Id = id;
            z.Add(record);

            await z.SaveChangesAsync();
            return(record.Id);
        }
            );

        Func <Task> action = () => ServiceProvider.WithScoped <IMediator>().Invoke(
            mediator => mediator.Send(new DeleteLaunchRecord.Request {
            Id = id
        })
            );
        await action.Should().ThrowAsync <NotAuthorizedException>();
    }
Beispiel #3
0
    public async Task Should_Remove_LaunchRecord()
    {
        var id = await ServiceProvider.WithScoped <RocketDbContext>()
                 .Invoke(
            async z =>
        {
            var faker  = new RocketFaker();
            var rocket = faker.Generate();
            var record = new LaunchRecordFaker(new[] { rocket }.ToList()).Generate();
            z.Add(rocket);
            z.Add(record);

            await z.SaveChangesAsync();
            return(record.Id);
        }
            );

        await ServiceProvider.WithScoped <IMediator>().Invoke(
            mediator => mediator.Send(new DeleteLaunchRecord.Request {
            Id = id
        })
            );

        ServiceProvider.WithScoped <RocketDbContext>().Invoke(c => c.LaunchRecords.Should().BeEmpty());
    }
    public async Task Should_List_Specific_Kinds_Of_LaunchRecords()
    {
        var client = new LaunchRecordClient(Factory.CreateClient());
        await ServiceProvider.WithScoped<RocketDbContext>()
                             .Invoke(
                                  async z =>
                                  {
                                      var faker = new RocketFaker();
                                      var rockets = faker.UseSeed(100).Generate(3);
                                      var records = new LaunchRecordFaker(rockets).UseSeed(100).Generate(10);
                                      z.AddRange(rockets);
                                      z.AddRange(records);
                                      await z.SaveChangesAsync();
                                  }
                              );

        var response = await client.ListLaunchRecordsAsync(RocketType.FalconHeavy);
        response.Result.Should().HaveCount(3);
    }
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            await _serviceProvider.WithScoped <RocketDbContext>().Invoke(
                async dbContext =>
            {
                await dbContext.Database.EnsureCreatedAsync(cancellationToken).ConfigureAwait(false);
                var rocketFaker = new RocketFaker();
                rocketFaker.UseSeed(0);
                var rockets     = rocketFaker.GenerateBetween(10, 100);
                var launchFaker = new LaunchRecordFaker(rockets);
                launchFaker.UseSeed(1);
                var launches = launchFaker.GenerateBetween(100, 1000);

                await dbContext.Rockets.AddRangeAsync(rockets, cancellationToken).ConfigureAwait(false);
                await dbContext.LaunchRecords.AddRangeAsync(launches, cancellationToken).ConfigureAwait(false);
                await dbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
            }
                ).ConfigureAwait(false);
        }
Beispiel #6
0
    public async Task Should_List_LaunchRecords()
    {
        await ServiceProvider.WithScoped <RocketDbContext>()
        .Invoke(
            async z =>
        {
            var faker   = new RocketFaker();
            var rockets = faker.Generate(3);
            var records = new LaunchRecordFaker(rockets).Generate(10);
            z.AddRange(rockets);
            z.AddRange(records);
            await z.SaveChangesAsync();
        }
            );

        var response = await ServiceProvider.WithScoped <IMediator>().Invoke(
            mediator => mediator.CreateStream(new ListLaunchRecords.Request(null)).ToListAsync()
            );

        response.Should().HaveCount(10);
    }
Beispiel #7
0
    public async Task Should_List_Specific_Kinds_Of_LaunchRecords()
    {
        var client = Factory.Services.GetRequiredService <IRocketClient>();
        await ServiceProvider.WithScoped <RocketDbContext>()
        .Invoke(
            async z =>
        {
            var faker   = new RocketFaker();
            var rockets = faker.UseSeed(100).Generate(3);
            var records = new LaunchRecordFaker(rockets).UseSeed(100).Generate(10);
            z.AddRange(rockets);
            z.AddRange(records);
            await z.SaveChangesAsync();
        }
            );

        var response = await client.GetFilteredLaunchRecords.ExecuteAsync(RocketType.FalconHeavy);

        response.EnsureNoErrors();

        response.Data !.LaunchRecords !.Nodes !.Should().HaveCount(3);
    }
Beispiel #8
0
    public async Task Should_Remove_LaunchRecord()
    {
        var client = new LaunchRecordClient(Factory.CreateClient());
        var id     = await ServiceProvider.WithScoped <RocketDbContext>()
                     .Invoke(
            async z =>
        {
            var faker  = new RocketFaker();
            var rocket = faker.Generate();
            var record = new LaunchRecordFaker(new[] { rocket }.ToList()).Generate();
            z.Add(rocket);
            z.Add(record);

            await z.SaveChangesAsync();
            return(record.Id);
        }
            );

        await client.DeleteLaunchRecordAsync(id.Value);

        ServiceProvider.WithScoped <RocketDbContext>().Invoke(c => c.LaunchRecords.Should().BeEmpty());
    }
Beispiel #9
0
    public async Task Should_ResponseMessage_When_MessageIsValid()
    {
        await _factory.Services.WithScoped <RocketDbContext>()
        .Invoke(
            async z =>
        {
            var faker   = new RocketFaker();
            var rockets = faker.Generate(3);
            var records = new LaunchRecordFaker(rockets).Generate(10);
            z.AddRange(rockets);
            z.AddRange(records);
            await z.SaveChangesAsync();
        }
            );

        // Given
        var client = new Grpc.Rockets.RocketsClient(_factory.CreateGrpcChannel());

        // When
        var response = await client.ListRockets(new ListRocketsRequest()).ResponseStream.ReadAllAsync().ToListAsync();

        // Then nothing happen.
        response.Should().HaveCountGreaterThan(0);
    }