public async Task TestGetVersion()
        {
            ApplicationUpdate     applicationUpdate = new ApplicationUpdate(TimeSpan.FromSeconds(30));
            Version               version           = new Version("1.0.0.0");
            ApplicationUpdateInfo info = await applicationUpdate.GetUpdateApplicationInfo(version);

            if (info != null)
            {
                Assert.IsTrue(info.Version > version);
                Assert.IsTrue(info.DownloadUrl.EndsWith(".zip"));

                info = await applicationUpdate.GetUpdateApplicationInfo(info.Version);

                Assert.IsNull(info);
            }
        }
        async Task CheckApplication(Application app)
        {
            ApplicationSetupInfo setupInfo = null;

            try
            {
                setupInfo = await app.GetSetupInfoAsync();

                //// TODO: Install an app which hits this code before this test runs

                Assert.NotNull(setupInfo.Eai);
                Assert.DoesNotThrow(() => { bool p = setupInfo.Refresh; });
            }
            catch (InternalServerErrorException e)
            {
                Assert.Contains("Internal Server Error", e.Message);
            }

            ApplicationArchiveInfo archiveInfo = await app.PackageAsync();

            Assert.DoesNotThrow(() =>
            {
                string p = app.Author;
                Assert.NotNull(p);
            });

            Assert.DoesNotThrow(() => { string p = app.ApplicationAuthor; });
            Assert.DoesNotThrow(() => { bool p = app.CheckForUpdates; });
            Assert.DoesNotThrow(() => { string p = app.Description; });
            Assert.DoesNotThrow(() => { string p = app.Label; });
            Assert.DoesNotThrow(() => { bool p = app.Refresh; });
            Assert.DoesNotThrow(() => { string p = app.Version; });
            Assert.DoesNotThrow(() => { bool p = app.Configured; });
            Assert.DoesNotThrow(() => { bool p = app.StateChangeRequiresRestart; });
            Assert.DoesNotThrow(() => { bool p = app.Visible; });

            ApplicationUpdateInfo updateInfo = await app.GetUpdateInfoAsync();

            Assert.NotNull(updateInfo.Eai);

            if (updateInfo.Update != null)
            {
                var update = updateInfo.Update;

                Assert.DoesNotThrow(() =>
                {
                    string p = updateInfo.Update.ApplicationName;
                });
                Assert.DoesNotThrow(() =>
                {
                    Uri p = updateInfo.Update.ApplicationUri;
                });
                Assert.DoesNotThrow(() =>
                {
                    string p = updateInfo.Update.ApplicationName;
                });
                Assert.DoesNotThrow(() =>
                {
                    string p = updateInfo.Update.ChecksumType;
                });
                Assert.DoesNotThrow(() =>
                {
                    string p = updateInfo.Update.Homepage;
                });
                Assert.DoesNotThrow(() =>
                {
                    bool p = updateInfo.Update.ImplicitIdRequired;
                });
                Assert.DoesNotThrow(() =>
                {
                    long p = updateInfo.Update.Size;
                });
                Assert.DoesNotThrow(() =>
                {
                    string p = updateInfo.Update.Version;
                });
            }

            Assert.DoesNotThrow(() => { DateTime p = updateInfo.Updated; });
        }
Exemple #3
0
        public void Application()
        {
            string  dummyString;
            bool    dummyBool;
            int     dummyInt;
            Service service = Connect();

            ApplicationCollection apps = service.GetApplicationsAsync().Result;

            foreach (Application app in apps)
            {
                try
                {
                    ApplicationSetupInfo applicationSetup = app.GetSetupInfoAsync().Result;
                    //string setupXml = applicationSetup.SetupXml;
                }
                catch (Exception)
                {
                    // silent exception, if setup doesn't exist, exception occurs
                }

                ApplicationArchiveInfo applicationArchive = app.PackageAsync().Result;
                dummyString = app.Author;
                dummyBool   = app.CheckForUpdates;
                dummyString = app.Description;
                dummyString = app.Label;
                dummyBool   = app.Refresh;
                dummyString = app.Version;
                dummyBool   = app.Configured;
                if (this.VersionCompare(service, "5.0") < 0)
                {
                    //dummyBool = app.IsManageable;
                }
                dummyBool = app.Visible;
                dummyBool = app.StateChangeRequiresRestart;
                ApplicationUpdateInfo applicationUpdate = app.GetUpdateInfoAsync().Result;
                //dummyString = applicationUpdate.Checksum;
                //dummyString = applicationUpdate.ChecksumType;
                //dummyString = applicationUpdate.Homepage;
                //dummyInt = applicationUpdate.UpdateSize;
                //dummyString = applicationUpdate.UpdateName;
                //dummyString = applicationUpdate.AppUrl;
                //dummyString = applicationUpdate.Version;
                //dummyBool = applicationUpdate.IsImplicitIdRequired;
            }

            if (apps.Any(a => a.Name == "sdk-tests"))
            {
                service = this.CleanApp("sdk-tests", service);
            }

            apps = service.GetApplicationsAsync().Result;
            Assert.False(apps.Any(a => a.Name == "sdk-tests"), assertRoot + "#1");

            ApplicationAttributes createArgs = new ApplicationAttributes();

            createArgs.ApplicationAuthor = "me";
            if (this.VersionCompare(service, "4.2.4") >= 0)
            {
                createArgs.Configured = false;
            }
            createArgs.Description = "this is a description";
            createArgs.Label       = "SDKTEST";
            if (this.VersionCompare(service, "5.0") < 0)
            {
                //createArgs.manageable", false);
            }
            //createArgs.template", "barebones");
            createArgs.Visible = false;
            service.CreateApplicationAsync("sdk-tests", "barebones", createArgs).Wait();
            apps.GetAsync().Wait();
            Assert.True(apps.Any(a => a.Name == "sdk-tests"), assertRoot + "#2");

            Application app2 = service.GetApplicationAsync("sdk-tests").Result;

            dummyBool = app2.CheckForUpdates;
            Assert.Equal("SDKTEST", app2.Label);
            Assert.Equal("me", app2.ApplicationAuthor);
            Assert.False(app2.Configured, assertRoot + "#5");
            if (this.VersionCompare(service, "5.0") < 0)
            {
                //Assert.False(app2.Manageable, assertRoot + "#6");
            }
            Assert.False(app2.Visible, assertRoot + "#7");

            // update the app
            ApplicationAttributes attr = new ApplicationAttributes();

            attr.ApplicationAuthor = "not me";
            attr.Description       = "new description";
            attr.Label             = "new label";
            attr.Visible           = false;
            if (this.VersionCompare(service, "5.0") < 0)
            {
                //app2.IsManageable = false;
            }
            //attr.Version = "5.0.0";
            app2.UpdateAsync(attr, true).Wait();
            app2.GetAsync().Wait();

            // check to see if args took.
            Assert.Equal("not me", app2.ApplicationAuthor);
            Assert.Equal("new description", app2.Description);
            Assert.Equal("new label", app2.Label);
            Assert.False(app2.Visible, assertRoot + "#11");
            //Assert.Equal("5.0.0", app2.Version);

            // archive (package) the application
            ApplicationArchiveInfo appArchive = app2.PackageAsync().Result;

            Assert.True(appArchive.ApplicationName.Length > 0, assertRoot + "#13");
            Assert.True(appArchive.Path.Length > 0, assertRoot + "#14");
            Assert.True(appArchive.Uri.AbsolutePath.Length > 0, assertRoot + "#15");

            ApplicationUpdateInfo appUpdate = app2.GetUpdateInfoAsync().Result;

            //ApplicationUpdate appUpdate = app2.AppUpdate();
            //Assert.True(appUpdate.ContainsKey("eai:acl"), assertRoot + "#16");

            service = this.CleanApp("sdk-tests", service);
            apps    = service.GetApplicationsAsync().Result;
            Assert.False(apps.Any(a => a.Name == "sdk-tests"), assertRoot + "#17");
        }
Exemple #4
0
        public async Task Application()
        {
            using (var service = await SdkHelper.CreateService())
            {
                ApplicationCollection apps = service.Applications;
                await apps.GetAllAsync();

                foreach (Application app in apps)
                {
                    await CheckApplication(app);
                }

                for (int i = 0; i < apps.Count; i++)
                {
                    await CheckApplication(apps[i]);
                }

                if (await service.Applications.RemoveAsync("sdk-tests"))
                {
                    await service.Server.RestartAsync(2 * 60 * 1000);

                    await service.LogOnAsync();
                }

                ApplicationAttributes attributes = new ApplicationAttributes
                {
                    ApplicationAuthor = "me",
                    Description       = "this is a description",
                    Label             = "SDKTEST",
                    Visible           = false
                };

                var testApp = await service.Applications.CreateAsync("sdk-tests", "barebones", attributes);

                testApp = await service.Applications.GetAsync("sdk-tests");

                Assert.Equal("SDKTEST", testApp.Label);
                Assert.Equal("me", testApp.ApplicationAuthor);
                Assert.Equal("nobody", testApp.Author);
                Assert.False(testApp.Configured);
                Assert.False(testApp.Visible);

                Assert.DoesNotThrow(() =>
                {
                    bool p = testApp.CheckForUpdates;
                });

                attributes = new ApplicationAttributes
                {
                    ApplicationAuthor = "not me",
                    Description       = "new description",
                    Label             = "new label",
                    Visible           = false,
                    Version           = "1.5"
                };

                //// Update the application

                await testApp.UpdateAsync(attributes, true);

                await testApp.GetAsync();

                Assert.Equal("not me", testApp.ApplicationAuthor);
                Assert.Equal("nobody", testApp.Author);
                Assert.Equal("new description", testApp.Description);
                Assert.Equal("new label", testApp.Label);
                Assert.Equal("1.5", testApp.Version);
                Assert.False(testApp.Visible);

                ApplicationUpdateInfo updateInfo = await testApp.GetUpdateInfoAsync();

                Assert.NotNull(updateInfo.Eai.Acl);

                //// Package the application

                ApplicationArchiveInfo archiveInfo = await testApp.PackageAsync();

                Assert.Equal("Package", archiveInfo.Title);
                Assert.NotEqual(DateTime.MinValue, archiveInfo.Updated);

                Assert.DoesNotThrow(() =>
                {
                    string p = archiveInfo.ApplicationName;
                });
                Assert.True(archiveInfo.ApplicationName.Length > 0);

                Assert.DoesNotThrow(() =>
                {
                    Eai p = archiveInfo.Eai;
                });
                Assert.NotNull(archiveInfo.Eai);
                Assert.NotNull(archiveInfo.Eai.Acl);

                Assert.DoesNotThrow(() =>
                {
                    string p = archiveInfo.Path;
                });
                Assert.True(archiveInfo.Path.Length > 0);

                Assert.DoesNotThrow(() =>
                {
                    bool p = archiveInfo.Refresh;
                });

                Assert.DoesNotThrow(() =>
                {
                    Uri p = archiveInfo.Uri;
                });
                Assert.True(archiveInfo.Uri.AbsolutePath.Length > 0);

                Assert.True(await service.Applications.RemoveAsync("sdk-tests"));
                await service.Server.RestartAsync(2 * 60 * 1000);
            }
        }