public async Task Should_Get_A_LaunchRecord()
    {
        var client = Factory.Services.GetRequiredService <IRocketClient>();
        var record = await ServiceProvider.WithScoped <RocketDbContext, IClock>()
                     .Invoke(
            async(context, clock) =>
        {
            var rocket = new ReadyRocket
            {
                Id           = RocketId.New(),
                Type         = CoreRocketType.Falcon9,
                SerialNumber = "12345678901234"
            };

            var record = new LaunchRecord
            {
                Partner             = "partner",
                Payload             = "geo-fence-ftl",
                RocketId            = rocket.Id,
                ScheduledLaunchDate = clock.GetCurrentInstant().ToDateTimeOffset(),
                PayloadWeightKg     = 100,
            };
            context.Add(rocket);
            context.Add(record);

            await context.SaveChangesAsync();
            return(record);
        }
            );

        var response = await client.GetLaunchRecord.ExecuteAsync(record.Id.Value);

        response.EnsureNoErrors();

        response.Data !.LaunchRecords !.Nodes ![0].Partner.Should().Be("partner");
Exemple #2
0
        /// <summary>
        /// Saves the application launch data.
        /// </summary>
        public void SaveLaunchData()
        {
            LaunchRecord launchRecord = new LaunchRecord()
            {
                RunCount            = _runCount,
                LastLaunchDate      = _lastLaunchDate,
                LastVersionLaunched = _lastVersionLaunched
            };

            byte[] bytes = _binarySerializer.Serialize(launchRecord);
            File.WriteAllBytes(Path.Combine(_saveDataFolder, _launchSaveFileName), bytes);
        }
    public async Task Should_Update_A_LaunchRecord()
    {
        var client = new LR.LaunchRecordsClient(Factory.CreateGrpcChannel());
        var clock  = ServiceProvider.GetRequiredService <IClock>();
        var record = await ServiceProvider.WithScoped <RocketDbContext, IClock>()
                     .Invoke(
            async(context, clk) =>
        {
            var rocket = new ReadyRocket
            {
                Id           = RocketId.New(),
                Type         = Core.Domain.RocketType.Falcon9,
                SerialNumber = "12345678901234"
            };
            context.Add(rocket);

            var record = new LaunchRecord
            {
                Partner             = "partner",
                Payload             = "geo-fence-ftl",
                RocketId            = rocket.Id,
                Rocket              = rocket,
                ScheduledLaunchDate = clk.GetCurrentInstant().ToDateTimeOffset(),
                PayloadWeightKg     = 100,
            };
            context.Add(record);

            await context.SaveChangesAsync();
            return(record);
        }
            );

        var launchDate = record.ScheduledLaunchDate.AddSeconds(1).ToTimestamp();
        await client.EditLaunchRecordAsync(
            new UpdateLaunchRecordRequest
        {
            Id                  = record.Id.ToString(),
            Partner             = "partner",
            Payload             = "geo-fence-ftl",
            RocketId            = record.RocketId.ToString(),
            ScheduledLaunchDate = launchDate,
            PayloadWeightKg     = 200,
        }
            );

        var response = await client.GetLaunchRecordsAsync(new GetLaunchRecordRequest { Id = record.Id.ToString() });

        response.ScheduledLaunchDate.Should().Be(launchDate);
        response.PayloadWeightKg.Should().Be(200);
    }
    public async Task Should_Update_A_LaunchRecord()
    {
        var record = await ServiceProvider.WithScoped <RocketDbContext, IClock>()
                     .Invoke(
            async(context, clock) =>
        {
            var rocket = new ReadyRocket
            {
                Id           = RocketId.New(),
                Type         = RocketType.Falcon9,
                SerialNumber = "12345678901234"
            };

            var record = new LaunchRecord
            {
                Partner             = "partner",
                Payload             = "geo-fence-ftl",
                RocketId            = rocket.Id,
                ScheduledLaunchDate = clock.GetCurrentInstant().ToDateTimeOffset(),
                PayloadWeightKg     = 100,
            };
            context.Add(rocket);
            context.Add(record);

            await context.SaveChangesAsync();
            return(record);
        }
            );

        var launchDate = record.ScheduledLaunchDate.ToInstant().Plus(Duration.FromSeconds(1));
        var response   = await ServiceProvider.WithScoped <IMediator, IClock>().Invoke(
            (mediator, clock) => mediator.Send(
                new EditLaunchRecord.Request
        {
            Id                  = record.Id,
            Partner             = "partner",
            Payload             = "geo-fence-ftl",
            RocketId            = record.RocketId,
            ScheduledLaunchDate = launchDate,
            PayloadWeightKg     = 200,
        }
                )
            );

        response.ScheduledLaunchDate.Should().Be(launchDate);
        response.PayloadWeightKg.Should().Be(200);
    }
Exemple #5
0
        private void LoadLaunchData()
        {
            string fileLocation = Path.Combine(_saveDataFolder, _launchSaveFileName);

            if (File.Exists(fileLocation))
            {
                byte[]       bytes        = File.ReadAllBytes(fileLocation);
                LaunchRecord launchRecord = _binarySerializer.Deserialize <LaunchRecord>(bytes);

                _runCount            = launchRecord.RunCount;
                _lastLaunchDate      = launchRecord.LastLaunchDate;
                _lastVersionLaunched = launchRecord.LastVersionLaunched;
            }
            else
            {
                _runCount            = 0;
                _lastLaunchDate      = DateTime.Now;
                _lastVersionLaunched = Assembly.GetExecutingAssembly().GetName().Version.ToString();

                SaveLaunchData();
            }
        }
Exemple #6
0
    public async Task Should_Get_A_LaunchRecord()
    {
        var client = new LaunchRecordClient(Factory.CreateClient());
        var record = await ServiceProvider.WithScoped <RocketDbContext, IClock>()
                     .Invoke(
            async(context, clock) =>
        {
            var rocket = new ReadyRocket
            {
                Id           = RocketId.New(),
                Type         = RocketType.Falcon9,
                SerialNumber = "12345678901234"
            };

            var record = new LaunchRecord
            {
                Partner             = "partner",
                Payload             = "geo-fence-ftl",
                RocketId            = rocket.Id,
                ScheduledLaunchDate = clock.GetCurrentInstant().ToDateTimeOffset(),
                PayloadWeightKg     = 100,
            };
            context.Add(rocket);
            context.Add(record);

            await context.SaveChangesAsync();
            return(record);
        }
            );

        var response = (await client.GetLaunchRecordAsync(record.Id.Value)).Result;

        response.Partner.Should().Be("partner");
        response.Payload.Should().Be("geo-fence-ftl");
        response.RocketType.Should().Be(HttpRocketType.Falcon9);
        response.RocketSerialNumber.Should().Be("12345678901234");
        response.ScheduledLaunchDate.Should().Be(record.ScheduledLaunchDate);
    }