Esempio n. 1
0
        public async Task Should_manage_languages()
        {
            var appName = Guid.NewGuid().ToString();

            // STEP 1: Add app.
            var createRequest = new CreateAppDto {
                Name = appName
            };

            await _.Apps.PostAppAsync(createRequest);


            // STEP 2: Add languages.
            await _.Apps.PostLanguageAsync(appName, new AddLanguageDto { Language = "de" });

            await _.Apps.PostLanguageAsync(appName, new AddLanguageDto { Language = "it" });

            await _.Apps.PostLanguageAsync(appName, new AddLanguageDto { Language = "fr" });

            var languages_1 = await _.Apps.GetLanguagesAsync(appName);

            var languageEN_1 = languages_1.Items.First(x => x.Iso2Code == "en");

            Assert.Equal(new string[] { "en", "de", "fr", "it" }, languages_1.Items.Select(x => x.Iso2Code).ToArray());
            Assert.True(languageEN_1.IsMaster);


            // STEP 3: Update German language.
            var updateRequest1 = new UpdateLanguageDto
            {
                Fallback = new string[]
                {
                    "fr",
                    "it"
                },
                IsOptional = true
            };

            var languages_2 = await _.Apps.PutLanguageAsync(appName, "de", updateRequest1);

            var languageDE_2 = languages_2.Items.First(x => x.Iso2Code == "de");

            Assert.Equal(new string[] { "fr", "it" }, languageDE_2.Fallback.ToArray());
            Assert.True(languageDE_2.IsOptional);


            // STEP 4: Update Italian language.
            var updateRequest2 = new UpdateLanguageDto
            {
                Fallback = new string[]
                {
                    "fr",
                    "de"
                }
            };

            var languages_3 = await _.Apps.PutLanguageAsync(appName, "it", updateRequest2);

            var languageDE_3 = languages_3.Items.First(x => x.Iso2Code == "it");

            Assert.Equal(new string[] { "fr", "de" }, languageDE_3.Fallback.ToArray());


            // STEP 5: Change master language.
            var masterRequest = new UpdateLanguageDto {
                IsMaster = true
            };

            var languages_4 = await _.Apps.PutLanguageAsync(appName, "it", masterRequest);

            var languageIT_4 = languages_4.Items.First(x => x.Iso2Code == "it");
            var languageEN_4 = languages_4.Items.First(x => x.Iso2Code == "en");

            Assert.True(languageIT_4.IsMaster);
            Assert.False(languageIT_4.IsOptional);
            Assert.False(languageEN_4.IsMaster);
            Assert.Empty(languageIT_4.Fallback);
            Assert.Equal(new string[] { "it", "de", "en", "fr" }, languages_4.Items.Select(x => x.Iso2Code).ToArray());


            // STEP 6: Remove language.
            var languages_5 = await _.Apps.DeleteLanguageAsync(appName, "fr");

            var languageDE_5 = languages_5.Items.First(x => x.Iso2Code == "de");

            Assert.Equal(new string[] { "it" }, languageDE_5.Fallback.ToArray());
            Assert.Equal(new string[] { "it", "de", "en" }, languages_5.Items.Select(x => x.Iso2Code).ToArray());
        }
Esempio n. 2
0
        public async Task <IActionResult> PostApp([FromBody] CreateAppDto request)
        {
            var response = await InvokeCommandAsync(request.ToCommand());

            return(CreatedAtAction(nameof(GetApps), response));
        }
Esempio n. 3
0
        public async Task Should_backup_and_restore_app()
        {
            var timeout = TimeSpan.FromMinutes(2);

            var appName        = Guid.NewGuid().ToString();
            var appNameRestore = $"{appName}-restore";

            // STEP 1: Create app
            var createRequest = new CreateAppDto {
                Name = appName
            };

            await _.Apps.PostAppAsync(createRequest);


            // STEP 2: Create backup
            await _.Backups.PostBackupAsync(appName);

            BackupJobDto backup = null;

            try
            {
                using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(2)))
                {
                    while (true)
                    {
                        cts.Token.ThrowIfCancellationRequested();

                        await Task.Delay(1000);

                        var backups = await _.Backups.GetBackupsAsync(appName);

                        if (backups.Items.Count > 0)
                        {
                            backup = backups.Items.FirstOrDefault();

                            break;
                        }
                    }
                }
            }
            catch (OperationCanceledException)
            {
                Assert.True(false, $"Could not retrieve backup within {timeout}.");
            }


            // STEP 3: Restore backup
            var uri = new Uri($"{_.ServerUrl}{backup._links["download"].Href}");

            var restoreRequest = new RestoreRequestDto {
                Url = uri, Name = appNameRestore
            };

            await _.Backups.PostRestoreJobAsync(restoreRequest);

            try
            {
                using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(2)))
                {
                    while (true)
                    {
                        cts.Token.ThrowIfCancellationRequested();

                        await Task.Delay(1000);

                        var job = await _.Backups.GetRestoreJobAsync();

                        if (job != null && job.Url == uri && job.Status == JobStatus.Completed)
                        {
                            break;
                        }
                    }
                }
            }
            catch (OperationCanceledException)
            {
                Assert.True(false, $"Could not retrieve restored app within {timeout}.");
            }
        }