bool Save(object entity)
        {
            var service   = entity as Service;
            var validated = new ServiceValidator().Validate(service);

            if (!validated)
            {
                return(false);
            }

            Service serviceToProcess = null;

            var existingService = _services.FirstOrDefault(s => s.Id == service.Id);

            if (existingService == null)
            {
                var profile = new ProfileServer().GetProfile();

                service.UserId = profile.Id;
                service.Id     = service.Id ?? Guid.NewGuid().ToString();

                _services.Add(service);
                serviceToProcess = service;
            }
            else
            {
                service.Update(existingService);
                serviceToProcess = existingService;
            }

            SaveData(serviceToProcess);
            SaveMaterials(serviceToProcess);

            return(true);
        }
Beispiel #2
0
        public void MultipleRequests_Sequential(int repeatCount)
        {
            // Verify that the server is able to handle multiple requests
            // submitted one at a time.

            var client = new ProfileClient(pipeName);

            using (var server = new ProfileServer(pipeName))
            {
                SetDefaultHandlers(server);
                server.Start();

                Assert.Equal("zero-profile", client.GetProfileValue("zero"));
                Assert.Equal("one-profile", client.GetProfileValue("one"));
                Assert.Equal("two-profile", client.GetProfileValue("two"));
                Assert.Equal("three-profile", client.GetProfileValue("three"));
                Assert.Equal("four-profile", client.GetProfileValue("four"));
                Assert.Equal("five-profile", client.GetProfileValue("five"));
                Assert.Equal("six-profile", client.GetProfileValue("six"));
                Assert.Equal("seven-profile", client.GetProfileValue("seven"));
                Assert.Equal("eight-profile", client.GetProfileValue("eight"));
                Assert.Equal("nine-profile", client.GetProfileValue("nine"));

                var callArgs = new Dictionary <string, string>();

                callArgs["command"] = "Hello World!";

                Assert.Equal("Hello World!", client.Call(callArgs));
            }
        }
        public void Read()
        {
            var profile   = new ProfileServer().GetProfile();
            var materials = Get(profile.Id);

            Publish(Messages.REQUEST_MATERIALS_RESPONSE, materials);
        }
        public override void Read()
        {
            var profile = new ProfileServer().GetProfile();
            var quotes  = ExecuteQueryStrategy(profile.Id);

            Publish(Messages.REQUEST_QUOTES_RESPONSE, quotes);
        }
        Quote GetQuote()
        {
            var registry = new CalculateTransaction.ViewModel();

            foreach (var sevice in SelectedServices)
            {
                registry.AddService.Execute(sevice);
            }

            var profile = new ProfileServer().GetProfile();

            _quote = new Quote()
            {
                Id              = Guid.NewGuid().ToString(),
                TypeName        = STATEMENT_TYPE_QUOTE,
                Title           = Title,
                UserId          = profile.Id,
                CloudSynced     = false,
                CreatedOn       = DateTime.Now,
                StatementNumber = GetStatementNumber(),
                Profile         = profile,
                Services        = new List <Service>(SelectedServices),
                Address         = new Address(),
                Total           = registry.Total,
                Subtotal        = registry.Subtotal,
                Tax             = registry.Tax
            };

            Subtotal = _quote.Subtotal;
            Tax      = _quote.Tax;
            Total    = _quote.Total;

            return(_quote);
        }
Beispiel #6
0
        /// <summary>
        /// Sets handlers that return reasonable default values.
        /// </summary>
        /// <param name="server">The assistant erver.</param>
        private void SetDefaultHandlers(ProfileServer server)
        {
            server.GetProfileValueHandler = (request, name) => ProfileHandlerResult.Create($"{name}-profile");

            server.GetSecretPasswordHandler =
                (request, name, vault, masterPassword) =>
            {
                var sb = new StringBuilder();

                sb.Append(name);

                if (vault != null)
                {
                    sb.AppendWithSeparator(vault, "-");
                }

                if (masterPassword != null)
                {
                    sb.AppendWithSeparator(masterPassword, "-");
                }

                sb.Append("-password");

                return(ProfileHandlerResult.Create(sb.ToString()));
            };

            server.GetSecretValueHandler =
                (request, name, vault, masterPassword) =>
            {
                var sb = new StringBuilder();

                sb.Append(name);

                if (vault != null)
                {
                    sb.AppendWithSeparator(vault, "-");
                }

                if (masterPassword != null)
                {
                    sb.AppendWithSeparator(masterPassword, "-");
                }

                sb.Append("-secret");

                return(ProfileHandlerResult.Create(sb.ToString()));
            };

            server.CallHandler =
                request =>
            {
                // We're just going to echo the value of the "command" argument.

                return(ProfileHandlerResult.Create(request.Args["command"]));
            };
        }
Beispiel #7
0
        public void Parse_BadProperty()
        {
            Assert.Equal("test[property", ProfileServer.ParseSecretName("test[property").Name);
            Assert.Null(ProfileServer.ParseSecretName("test[property").Property);

            Assert.Equal("testproperty]", ProfileServer.ParseSecretName("testproperty]").Name);
            Assert.Null(ProfileServer.ParseSecretName("testproperty]").Property);

            Assert.Equal("test", ProfileServer.ParseSecretName("test[]").Name);
            Assert.Null(ProfileServer.ParseSecretName("test[]").Property);
        }
Beispiel #8
0
        public void GetSecretPassword(int repeatCount)
        {
            var client = new ProfileClient(pipeName);

            using (var server = new ProfileServer(pipeName))
            {
                SetDefaultHandlers(server);
                server.Start();

                Assert.Equal("test-password", client.GetSecretPassword("test"));
            }
        }
Beispiel #9
0
        public void GetSecretValue_UsingMasterPassword(int repeatCount)
        {
            var client = new ProfileClient(pipeName);

            using (var server = new ProfileServer(pipeName))
            {
                SetDefaultHandlers(server);
                server.Start();

                Assert.Equal("test-vault-master-secret", client.GetSecretValue("test", "vault", "master"));
            }
        }
        public override void Read()
        {
            var profileId = new ProfileServer().GetProfile()?.Id;

            if (profileId == null)
            {
                return;
            }

            var serviceMaterials = _databaseConnection.Table <ServiceMaterial>().Where(m => m.UserId == profileId);

            Publish(Messages.REQUEST_SERVICE_MATERIALS_MATERIALS_FROM_SERVICE_ID_RESPONSE, serviceMaterials);
        }
Beispiel #11
0
        public void GetSecretValue_Exception(int repeatCount)
        {
            var client = new ProfileClient(pipeName);

            using (var server = new ProfileServer(pipeName))
            {
                SetDefaultHandlers(server);

                server.GetSecretValueHandler = (request, name, value, masterpassword) => throw new Exception("test exception");

                server.Start();

                Assert.Throws <ProfileException>(() => client.GetSecretValue("test"));
            }
        }
        void OnGenerate(object obj)
        {
            var profile       = new ProfileServer().GetProfile();
            var canEmailQuote = !string.IsNullOrEmpty(profile.Email);

            if (!canEmailQuote)
            {
                Publish(Messages.REQUEST_VIEW_PROFILE);
            }
            else
            {
                InitializeCustomer();
                Publish(Messages.REQUEST_VIEW_QUOTE, _customer);
            }
        }
Beispiel #13
0
        public void get_material_from_service_material()
        {
            // Setup
            ClearSubscriptions();

            var mock = new Mock();
            var serviceMaterialsDatabase = mock.PrepareServiceMaterialsDependencies();

            new Autonomy().Activate();

            var profileId = new ProfileServer().GetProfile().Id;

            var material = new Material()
            {
                Name = SOME_TEXT, UserId = profileId
            };

            Publish(Messages.REQUEST_SAVE_MATERIAL, material);

            var service = new Service()
            {
                Name = SOME_TEXT, UserId = profileId
            };

            Publish(Messages.REQUEST_SAVE_SERVICE, service);

            var serviceMaterial = new ServiceMaterial()
            {
                MaterialId = material.Id,
                ServiceId  = service.Id,
                Quantity   = 1,
                UserId     = profileId
            };

            Publish(Messages.REQUEST_SAVE_SERVICE_MATERIAL, serviceMaterial);

            // Test
            Material materialResult = null;

            Subscribe(Messages.REQUEST_SERVICE_MATERIAL_RESPONSE, obj => materialResult = obj as Material);
            Publish(Messages.REQUEST_SERVICE_MATERIAL, material.Id);

            // Verify
            var expected = material == materialResult;

            Assert.IsTrue(expected);
        }
Beispiel #14
0
        public void profile_created_on_new_service()
        {
            // Setup
            new Bootstrap().Run();

            var viewModel = new ViewModel();

            viewModel.Name          = SOME_TEXT;
            viewModel.LaborCost     = SOME_DECIMAL_VALUE.ToString();
            viewModel.TaxPercentage = SOME_DECIMAL_VALUE.ToString();
            viewModel.Description   = SOME_TEXT;

            // Test
            viewModel.SaveCommand.Execute(null);

            // Verify
            var profileCreated = new ProfileServer().GetProfile() != null;

            Assert.IsTrue(profileCreated);
        }
Beispiel #15
0
        public void profile_created_on_new_material()
        {
            // Setup
            new Bootstrap().Run();

            var manageMaterialsViewModel = new ManageMaterials.ViewModel();
            var viewModel = new ViewModel();

            // Test
            viewModel.Name        = SOME_TEXT;
            viewModel.Description = SOME_TEXT;
            viewModel.Quantity    = SOME_DECIMAL_VALUE.ToString();
            viewModel.UnitType    = SOME_TEXT;
            viewModel.BaseCost    = SOME_DECIMAL_VALUE.ToString();
            viewModel.MarkupPrice = SOME_DECIMAL_VALUE.ToString();
            viewModel.Save.Execute(null);

            // Verify
            var expected = new ProfileServer().GetProfile() != null;

            Assert.IsTrue(expected);
        }
Beispiel #16
0
        /// <summary>
        /// Implementation of the test itself.
        /// </summary>
        /// <returns>true if the test passes, false otherwise.</returns>
        public override async Task <bool> RunAsync()
        {
            IPAddress ServerIp    = (IPAddress)ArgumentValues["Server IP"];
            int       PrimaryPort = (int)ArgumentValues["primary Port"];

            log.Trace("(ServerIp:'{0}',PrimaryPort:{1})", ServerIp, PrimaryPort);

            bool res = false;

            Passed = false;

            ProtocolClient client        = new ProtocolClient();
            ProfileServer  profileServer = null;

            try
            {
                MessageBuilder mb = client.MessageBuilder;

                // Step 1
                log.Trace("Step 1");
                // Get port list.
                await client.ConnectAsync(ServerIp, PrimaryPort, false);

                Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>();
                bool listPortsOk = await client.ListServerPorts(rolePorts);

                client.CloseConnection();

                await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.SrNeighbor], true);

                bool verifyIdentityOk = await client.VerifyIdentityAsync();

                Message requestMessage = mb.CreateFinishNeighborhoodInitializationRequest();
                await client.SendMessageAsync(requestMessage);

                Message responseMessage = await client.ReceiveMessageAsync();

                bool idOk     = responseMessage.Id == requestMessage.Id;
                bool statusOk = responseMessage.Response.Status == Status.ErrorRejected;

                bool finishNeighborhoodInitializationOk = idOk && statusOk;


                requestMessage = mb.CreateNeighborhoodSharedProfileUpdateRequest();
                await client.SendMessageAsync(requestMessage);

                responseMessage = await client.ReceiveMessageAsync();

                idOk     = responseMessage.Id == requestMessage.Id;
                statusOk = responseMessage.Response.Status == Status.ErrorRejected;

                bool neighborhoodSharedProfileUpdateOk = idOk && statusOk;



                requestMessage = mb.CreateStopNeighborhoodUpdatesRequest();
                await client.SendMessageAsync(requestMessage);

                responseMessage = await client.ReceiveMessageAsync();

                idOk     = responseMessage.Id == requestMessage.Id;
                statusOk = responseMessage.Response.Status == Status.ErrorNotFound;

                bool stopNeighborhoodUpdatesOk = idOk && statusOk;



                bool step1Ok = listPortsOk && verifyIdentityOk && finishNeighborhoodInitializationOk && neighborhoodSharedProfileUpdateOk && stopNeighborhoodUpdatesOk;
                log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");


                Passed = step1Ok;

                res = true;
            }
            catch (Exception e)
            {
                log.Error("Exception occurred: {0}", e.ToString());
            }
            client.Dispose();

            foreach (ProtocolClient protocolClient in TestProfiles.Values)
            {
                protocolClient.Dispose();
            }

            if (profileServer != null)
            {
                profileServer.Shutdown();
            }

            log.Trace("(-):{0}", res);
            return(res);
        }
Beispiel #17
0
        public void ProfileReferences()
        {
            // Verify that [IProfileClient] integration works by starting a profile
            // server, injecting an [IProfileClient] implementation and then verifying
            // that secret passwords, secret values, and profile values can be
            // resolved.

            var pipeName = Guid.NewGuid().ToString("d");
            var server   = new ProfileServer(pipeName);

            server.GetProfileValueHandler =
                (request, name) =>
            {
                if (name == "missing")
                {
                    return(ProfileHandlerResult.CreateError(request, ProfileStatus.NotFound, $"[{name}] variable not found."));
                }

                return(ProfileHandlerResult.Create($"{name}-profile"));
            };

            server.GetSecretPasswordHandler =
                (request, name, vault, masterPassword) =>
            {
                if (name == "missing")
                {
                    return(ProfileHandlerResult.CreateError(request, ProfileStatus.NotFound, $"[{name}] variable not found."));
                }

                if (vault == null)
                {
                    return(ProfileHandlerResult.Create($"{name}-password"));
                }
                else
                {
                    return(ProfileHandlerResult.Create($"{name}-password-{vault}"));
                }
            };

            server.GetSecretValueHandler =
                (request, name, vault, masterPassword) =>
            {
                if (name == "missing")
                {
                    return(ProfileHandlerResult.CreateError(request, ProfileStatus.NotFound, $"[{name}] variable not found."));
                }

                if (vault == null)
                {
                    return(ProfileHandlerResult.Create($"{name}-secret"));
                }
                else
                {
                    return(ProfileHandlerResult.Create($"{name}-secret-{vault}"));
                }
            };

            server.Start();

            try
            {
                var client = new ProfileClient(pipeName);

                NeonHelper.ServiceContainer.AddSingleton <IProfileClient>(client);

                //-------------------------------------------------------------
                // Verify secret passwords

                var source = "TEST = $<<<password:test>>>";
                var output = new PreprocessReader(source).ReadToEnd().Trim();

                Assert.Equal("TEST = test-password", output);

                source = "TEST = $<<<password:test:vault>>>";
                output = new PreprocessReader(source).ReadToEnd().Trim();

                Assert.Equal("TEST = test-password-vault", output);

                Assert.Throws <ProfileException>(() => new PreprocessReader("TEST = $<<<password:missing>>>").ReadToEnd());

                //-------------------------------------------------------------
                // Verify secret values

                source = "TEST = $<<<secret:test>>>";
                output = new PreprocessReader(source).ReadToEnd().Trim();

                Assert.Equal("TEST = test-secret", output);

                source = "TEST = $<<<secret:test:vault>>>";
                output = new PreprocessReader(source).ReadToEnd().Trim();

                Assert.Equal("TEST = test-secret-vault", output);

                Assert.Throws <ProfileException>(() => new PreprocessReader("TEST = $<<<secret:missing>>>").ReadToEnd());

                //-------------------------------------------------------------
                // Verify secret values targeting a specific property.

                source = "TEST = $<<<secret:test[field]>>>";
                output = new PreprocessReader(source).ReadToEnd().Trim();

                Assert.Equal("TEST = test[field]-secret", output);

                source = "TEST = $<<<secret:test[field]:vault>>>";
                output = new PreprocessReader(source).ReadToEnd().Trim();

                Assert.Equal("TEST = test[field]-secret-vault", output);

                Assert.Throws <ProfileException>(() => new PreprocessReader("TEST = $<<<secret:missing>>>").ReadToEnd());

                //-------------------------------------------------------------
                // Verify profile values

                source = "TEST = $<<<profile:test>>>";
                output = new PreprocessReader(source).ReadToEnd().Trim();

                Assert.Equal("TEST = test-profile", output);

                Assert.Throws <ProfileException>(() => new PreprocessReader("TEST = $<<<profile:missing>>>").ReadToEnd());
            }
            finally
            {
                NeonHelper.ServiceContainer.Remove(NeonHelper.ServiceContainer.Single(service => service.ServiceType == typeof(IProfileClient)));

                server.Dispose();
            }
        }
Beispiel #18
0
        public async Task MultipleRequests_Parallel(int repeatCount)
        {
            // Verify that the server is able to handle multiple requests
            // submitted in parallel but with only one server thread.

            var client = new ProfileClient(pipeName);

            using (var server = new ProfileServer(pipeName, threadCount: 1))
            {
                SetDefaultHandlers(server);
                server.Start();

                await Task.Run(() => Assert.Equal("zero-profile", client.GetProfileValue("zero")));

                await Task.Run(() => Assert.Equal("one-profile", client.GetProfileValue("one")));

                await Task.Run(() => Assert.Equal("two-profile", client.GetProfileValue("two")));

                await Task.Run(() => Assert.Equal("three-profile", client.GetProfileValue("three")));

                await Task.Run(() => Assert.Equal("four-profile", client.GetProfileValue("four")));

                await Task.Run(() => Assert.Equal("five-profile", client.GetProfileValue("five")));

                await Task.Run(() => Assert.Equal("six-profile", client.GetProfileValue("six")));

                await Task.Run(() => Assert.Equal("seven-profile", client.GetProfileValue("seven")));

                await Task.Run(() => Assert.Equal("eight-profile", client.GetProfileValue("eight")));

                await Task.Run(() => Assert.Equal("nine-profile", client.GetProfileValue("nine")));
            }

            // Verify that the server is able to handle multiple requests
            // submitted in parallel with multiple server threads.

            using (var server = new ProfileServer(pipeName, threadCount: 10))
            {
                SetDefaultHandlers(server);
                server.Start();

                await Task.Run(() => Assert.Equal("zero-profile", client.GetProfileValue("zero")));

                await Task.Run(() => Assert.Equal("one-profile", client.GetProfileValue("one")));

                await Task.Run(() => Assert.Equal("two-profile", client.GetProfileValue("two")));

                await Task.Run(() => Assert.Equal("three-profile", client.GetProfileValue("three")));

                await Task.Run(() => Assert.Equal("four-profile", client.GetProfileValue("four")));

                await Task.Run(() => Assert.Equal("five-profile", client.GetProfileValue("five")));

                await Task.Run(() => Assert.Equal("six-profile", client.GetProfileValue("six")));

                await Task.Run(() => Assert.Equal("seven-profile", client.GetProfileValue("seven")));

                await Task.Run(() => Assert.Equal("eight-profile", client.GetProfileValue("eight")));

                await Task.Run(() => Assert.Equal("nine-profile", client.GetProfileValue("nine")));
            }
        }
Beispiel #19
0
    /// <summary>
    /// Implementation of the test itself.
    /// </summary>
    /// <returns>true if the test passes, false otherwise.</returns>
    public override async Task<bool> RunAsync()
    {
      IPAddress ServerIp = (IPAddress)ArgumentValues["Server IP"];
      int PrimaryPort = (int)ArgumentValues["primary Port"];
      int BasePort = (int)ArgumentValues["Base Port"];
      log.Trace("(ServerIp:'{0}',PrimaryPort:{1},BasePort:{2})", ServerIp, PrimaryPort, BasePort);

      bool res = false;
      Passed = false;

      ProtocolClient client = new ProtocolClient();
      ProfileServer profileServer = null;
      try
      {
        MessageBuilder mb = client.MessageBuilder;

        // Step 1
        log.Trace("Step 1");
        // Get port list.
        await client.ConnectAsync(ServerIp, PrimaryPort, false);
        Dictionary<ServerRoleType, uint> rolePorts = new Dictionary<ServerRoleType, uint>();
        bool listPortsOk = await client.ListServerPorts(rolePorts);
        client.CloseConnection();


        bool profileInitializationOk = true;
        byte[] testImageData = File.ReadAllBytes(Path.Combine("images", TestName + ".jpg"));

        int profileIndex = 1;
        int profileCount = 10;
        for (int i = 0; i < profileCount; i++)
        {
          ProtocolClient profileClient = new ProtocolClient();
          profileClient.InitializeRandomProfile(profileIndex, testImageData);
          profileIndex++;

          if (!await profileClient.RegisterAndInitializeProfileAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], (int)rolePorts[ServerRoleType.ClCustomer]))
          {
            profileClient.Dispose();
            profileInitializationOk = false;
            break;
          }

          TestProfiles.Add(profileClient.Profile.Name, profileClient);
        }

        profileServer = new ProfileServer("TestServer", ServerIp, BasePort, client.GetIdentityKeys());
        bool serverStartOk = profileServer.Start();

        bool step1Ok = listPortsOk && profileInitializationOk && serverStartOk;
        log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");



        // Step 2
        log.Trace("Step 2");
        await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.SrNeighbor], true);
        bool neighborhoodInitializationProcessOk = await client.NeighborhoodInitializationProcessAsync(profileServer.PrimaryPort, 1, TestProfiles);

        bool step2Ok = neighborhoodInitializationProcessOk;

        log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");


        // Step 3
        log.Trace("Step 3");

        profileInitializationOk = true;
        profileCount = 5;
        Dictionary<string, ProtocolClient> newProfiles = new Dictionary<string, ProtocolClient>(StringComparer.Ordinal);
        for (int i = 0; i < profileCount; i++)
        {
          ProtocolClient profileClient = new ProtocolClient();
          profileClient.InitializeRandomProfile(profileIndex, testImageData);
          profileIndex++;

          if (!await profileClient.RegisterAndInitializeProfileAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], (int)rolePorts[ServerRoleType.ClCustomer]))
          {
            profileClient.Dispose();
            profileInitializationOk = false;
            break;
          }

          TestProfiles.Add(profileClient.Profile.Name, profileClient);
          newProfiles.Add(profileClient.Profile.Name, profileClient);
        }

        // Wait at most 12 minutes for updates from the server.
        List<SharedProfileAddItem> addUpdates = new List<SharedProfileAddItem>();
        bool profilesOk = false;
        for (int time = 0; time < 12 * 60; time++) 
        {
          await Task.Delay(1000);

          // Meanwhile we expect updates to arrive on our simulated profile server.
          bool error = false;
          List<IncomingServerMessage> psMessages = profileServer.GetMessageList();
          foreach (IncomingServerMessage ism in psMessages)
          {
            if (ism.Role != ServerRole.ServerNeighbor) continue;
            Message message = ism.IncomingMessage;

            if ((message.MessageTypeCase == Message.MessageTypeOneofCase.Request)
              && (message.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.ConversationRequest)
              && (message.Request.ConversationRequest.RequestTypeCase == ConversationRequest.RequestTypeOneofCase.NeighborhoodSharedProfileUpdate))
            {
              foreach (SharedProfileUpdateItem updateItem in message.Request.ConversationRequest.NeighborhoodSharedProfileUpdate.Items)
              {
                if (updateItem.ActionTypeCase == SharedProfileUpdateItem.ActionTypeOneofCase.Add)
                {
                  SharedProfileAddItem addItem = updateItem.Add;
                  addUpdates.Add(addItem);
                }
                else
                {
                  log.Trace("Received invalid update action type {0}.", updateItem.ActionTypeCase);
                  error = true;
                  break;
                }
              }
            }

            if (error) break;
          }
          // Terminate if any error occurred.
          if (error) break;

          // Terminate if the received profiles match what is expected.
          profilesOk = client.CheckProfileListMatchAddItems(newProfiles, addUpdates);
          if (profilesOk) break;

          // Terminate if we do not expect any more updates to come.
          if (addUpdates.Count >= newProfiles.Count) break;
        }

        bool step3Ok = profileInitializationOk && profilesOk;

        log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED");


        Passed = step1Ok && step2Ok && step3Ok;

        res = true;
      }
      catch (Exception e)
      {
        log.Error("Exception occurred: {0}", e.ToString());
      }
      client.Dispose();

      foreach (ProtocolClient protocolClient in TestProfiles.Values)
        protocolClient.Dispose();

      if (profileServer != null) profileServer.Shutdown();

      log.Trace("(-):{0}", res);
      return res;
    }
Beispiel #20
0
 public IProfile(UserProfile profile)
 {
     _profileServer = new ProfileServer(profile);
 }
Beispiel #21
0
 public void Parse_WithProperty()
 {
     Assert.Equal("test", ProfileServer.ParseSecretName("test[property]").Name);
     Assert.Equal("property", ProfileServer.ParseSecretName("test[property]").Property);
 }
Beispiel #22
0
 public void Parse_NoProperty()
 {
     Assert.Equal("test", ProfileServer.ParseSecretName("test").Name);
     Assert.Null(ProfileServer.ParseSecretName("test").Property);
 }
Beispiel #23
0
 public void Parse_Empty()
 {
     Assert.Equal(string.Empty, ProfileServer.ParseSecretName(string.Empty).Name);
     Assert.Null(ProfileServer.ParseSecretName(string.Empty).Property);
 }
Beispiel #24
0
        /// <summary>
        /// Implementation of the test itself.
        /// </summary>
        /// <returns>true if the test passes, false otherwise.</returns>
        public override async Task <bool> RunAsync()
        {
            IPAddress ServerIp    = (IPAddress)ArgumentValues["Server IP"];
            int       PrimaryPort = (int)ArgumentValues["primary Port"];
            int       BasePort    = (int)ArgumentValues["Base Port"];
            int       LocPort     = (int)ArgumentValues["LOC Port"];

            log.Trace("(ServerIp:'{0}',PrimaryPort:{1},BasePort:{2},LocPort:{3})", ServerIp, PrimaryPort, BasePort, LocPort);

            bool res = false;

            Passed = false;

            ProtocolClient client        = new ProtocolClient();
            ProfileServer  profileServer = null;
            LocServer      locServer     = null;

            try
            {
                MessageBuilder mb = client.MessageBuilder;

                // Step 1
                log.Trace("Step 1");

                // Get port list.
                await client.ConnectAsync(ServerIp, PrimaryPort, false);

                Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>();
                bool listPortsOk = await client.ListServerPorts(rolePorts);

                client.CloseConnection();

                // Create identities.
                for (int i = 0; i < ProfileNames.Count; i++)
                {
                    byte[] imageData = ProfileImages[i] != null?File.ReadAllBytes(ProfileImages[i]) : null;

                    ProtocolClient profileClient = new ProtocolClient();
                    profileClient.Profile = new ClientProfile()
                    {
                        Version        = SemVer.V100,
                        Name           = ProfileNames[i],
                        Type           = ProfileTypes[i],
                        ProfileImage   = imageData,
                        ThumbnailImage = imageData,
                        Location       = ProfileLocations[i],
                        ExtraData      = ProfileExtraData[i],
                        PublicKey      = profileClient.GetIdentityKeys().PublicKey
                    };
                    TestProfiles.Add(profileClient.Profile.Name, profileClient);
                }


                // Start simulated profile server.
                profileServer = new ProfileServer("TestProfileServer", ServerIp, BasePort, client.GetIdentityKeys(), new GpsLocation(1, 2));
                bool profileServerStartOk = profileServer.Start();

                // Start simulated LOC server.
                locServer = new LocServer("TestLocServer", ServerIp, LocPort);
                bool locServerStartOk = locServer.Start();

                await locServer.WaitForProfileServerConnectionAsync();

                bool step1Ok = profileServerStartOk && locServerStartOk;
                log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");


                // Step 2
                log.Trace("Step 2");

                // Announce new neighbor.
                Iop.Locnet.NeighbourhoodChange change = new Iop.Locnet.NeighbourhoodChange()
                {
                    AddedNodeInfo = profileServer.GetNodeInfo(LocPort)
                };

                bool changeNotificationOk = await locServer.SendChangeNotification(change);

                // Wait for start of neighborhood initialization process.
                IncomingServerMessage incomingServerMessage = await profileServer.WaitForConversationRequest(ServerRole.ServerNeighbor, ConversationRequest.RequestTypeOneofCase.StartNeighborhoodInitialization);


                // Send update.
                List <SharedProfileUpdateItem> updateItems = new List <SharedProfileUpdateItem>();
                foreach (ProtocolClient pc in TestProfiles.Values)
                {
                    updateItems.Add(pc.GetSharedProfileUpdateAddItem());
                }

                Message updateRequest = await profileServer.SendNeighborhoodSharedProfileUpdateRequest(incomingServerMessage.Client, updateItems);

                incomingServerMessage = await profileServer.WaitForResponse(ServerRole.ServerNeighbor, updateRequest);

                bool statusOk = incomingServerMessage.IncomingMessage.Response.Status == Status.Ok;
                bool updateOk = (updateRequest != null) && statusOk;


                // Finish neighborhood initialization process.
                Message finishRequest = await profileServer.SendFinishNeighborhoodInitializationRequest(incomingServerMessage.Client);

                incomingServerMessage = await profileServer.WaitForResponse(ServerRole.ServerNeighbor, finishRequest);

                statusOk = incomingServerMessage.IncomingMessage.Response.Status == Status.Ok;
                bool finishOk = (finishRequest != null) && statusOk;


                bool step2Ok = changeNotificationOk && updateOk && finishOk;
                log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");



                // Step 3
                log.Trace("Step 3");
                await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);

                bool startConversationOk = await client.StartConversationAsync();

                Message requestMessage = mb.CreateProfileSearchRequest(null, null, null, null, 0, 100, 100, false, true);
                await client.SendMessageAsync(requestMessage);

                Message responseMessage = await client.ReceiveMessageAsync();

                bool idOk = responseMessage.Id == requestMessage.Id;
                statusOk = responseMessage.Response.Status == Status.Ok;

                HashSet <byte[]> expectedCoveredServers = new HashSet <byte[]>(StructuralEqualityComparer <byte[]> .Default)
                {
                    client.GetIdentityId(), Crypto.Sha256(client.ServerKey)
                };
                HashSet <byte[]> realCoveredServers = new HashSet <byte[]>(StructuralEqualityComparer <byte[]> .Default);
                foreach (ByteString csId in responseMessage.Response.ConversationResponse.ProfileSearch.CoveredServers)
                {
                    realCoveredServers.Add(csId.ToByteArray());
                }
                bool coveredServersOk = expectedCoveredServers.SetEquals(realCoveredServers);

                bool profileListOk = client.CheckProfileListMatchSearchResultItems(TestProfiles, responseMessage.Response.ConversationResponse.ProfileSearch.Profiles.ToList(), false, false, client.GetIdentityId(), true);

                // Step 3 Acceptance
                bool step3Ok = startConversationOk && idOk && statusOk && profileListOk && coveredServersOk;

                log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED");


                Passed = step1Ok && step2Ok && step3Ok;

                res = true;
            }
            catch (Exception e)
            {
                log.Error("Exception occurred: {0}", e.ToString());
            }
            client.Dispose();

            foreach (ProtocolClient protocolClient in TestProfiles.Values)
            {
                protocolClient.Dispose();
            }

            if (profileServer != null)
            {
                profileServer.Shutdown();
            }
            if (locServer != null)
            {
                locServer.Shutdown();
            }

            log.Trace("(-):{0}", res);
            return(res);
        }
Beispiel #25
0
        /// <summary>
        /// Implementation of the test itself.
        /// </summary>
        /// <returns>true if the test passes, false otherwise.</returns>
        public override async Task <bool> RunAsync()
        {
            IPAddress ServerIp    = (IPAddress)ArgumentValues["Server IP"];
            int       PrimaryPort = (int)ArgumentValues["primary Port"];
            int       BasePort    = (int)ArgumentValues["Base Port"];

            log.Trace("(ServerIp:'{0}',PrimaryPort:{1},BasePort:{2})", ServerIp, PrimaryPort, BasePort);

            bool res = false;

            Passed = false;

            ProtocolClient client1       = new ProtocolClient();
            ProtocolClient client2       = new ProtocolClient(0, SemVer.V100, client1.GetIdentityKeys());
            ProfileServer  profileServer = null;

            try
            {
                MessageBuilder mb1 = client1.MessageBuilder;
                MessageBuilder mb2 = client2.MessageBuilder;

                // Step 1
                log.Trace("Step 1");
                // Get port list.
                await client1.ConnectAsync(ServerIp, PrimaryPort, false);

                Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>();
                bool listPortsOk = await client1.ListServerPorts(rolePorts);

                client1.CloseConnection();


                bool   profileInitializationOk = true;
                byte[] testImageData           = File.ReadAllBytes(Path.Combine("images", TestName + ".jpg"));

                int profileIndex = 1;
                int profileCount = 10;
                for (int i = 0; i < profileCount; i++)
                {
                    ProtocolClient profileClient = new ProtocolClient();
                    profileClient.InitializeRandomProfile(profileIndex, testImageData);
                    profileIndex++;

                    if (!await profileClient.RegisterAndInitializeProfileAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], (int)rolePorts[ServerRoleType.ClCustomer]))
                    {
                        profileClient.Dispose();
                        profileInitializationOk = false;
                        break;
                    }

                    TestProfiles.Add(profileClient.Profile.Name, profileClient);
                }

                profileServer = new ProfileServer("TestServer", ServerIp, BasePort, client1.GetIdentityKeys());
                bool serverStartOk = profileServer.Start();

                bool step1Ok = listPortsOk && profileInitializationOk && serverStartOk;
                log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");



                // Step 2
                log.Trace("Step 2");
                await client1.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.SrNeighbor], true);

                bool verifyIdentityOk = await client1.VerifyIdentityAsync();

                // Start neighborhood initialization process.
                Message requestMessage = mb1.CreateStartNeighborhoodInitializationRequest((uint)profileServer.PrimaryPort, (uint)profileServer.ServerNeighborPort);
                await client1.SendMessageAsync(requestMessage);

                Message responseMessage = await client1.ReceiveMessageAsync();

                bool idOk     = responseMessage.Id == requestMessage.Id;
                bool statusOk = responseMessage.Response.Status == Status.Ok;
                bool startNeighborhoodInitializationOk = idOk && statusOk;


                // Wait for update request.
                Message serverRequestMessage  = null;
                Message clientResponseMessage = null;

                List <SharedProfileAddItem> receivedItems = new List <SharedProfileAddItem>();
                bool error = false;
                while (!error)
                {
                    serverRequestMessage = await client1.ReceiveMessageAsync();

                    bool isNspUpdate = serverRequestMessage.MessageTypeCase == Message.MessageTypeOneofCase.Request &&
                                       serverRequestMessage.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.ConversationRequest &&
                                       serverRequestMessage.Request.ConversationRequest.RequestTypeCase == ConversationRequest.RequestTypeOneofCase.NeighborhoodSharedProfileUpdate;

                    bool isNspFinish = serverRequestMessage.MessageTypeCase == Message.MessageTypeOneofCase.Request &&
                                       serverRequestMessage.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.ConversationRequest &&
                                       serverRequestMessage.Request.ConversationRequest.RequestTypeCase == ConversationRequest.RequestTypeOneofCase.FinishNeighborhoodInitialization;

                    if (isNspFinish)
                    {
                        break;
                    }

                    if (!isNspUpdate)
                    {
                        error = true;
                        break;
                    }

                    clientResponseMessage = mb1.CreateNeighborhoodSharedProfileUpdateResponse(serverRequestMessage);
                    await client1.SendMessageAsync(clientResponseMessage);

                    foreach (SharedProfileUpdateItem updateItem in serverRequestMessage.Request.ConversationRequest.NeighborhoodSharedProfileUpdate.Items)
                    {
                        if (updateItem.ActionTypeCase != SharedProfileUpdateItem.ActionTypeOneofCase.Add)
                        {
                            log.Trace("Received invalid update item action type '{0}'.", updateItem.ActionTypeCase);
                            error = true;
                            break;
                        }

                        log.Trace("Received profile name '{0}'.", updateItem.Add.Name);
                        receivedItems.Add(updateItem.Add);
                    }

                    if (error)
                    {
                        break;
                    }
                }

                bool step2Ok = verifyIdentityOk && startNeighborhoodInitializationOk;

                log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");


                // Step 3
                log.Trace("Step 3");

                profileInitializationOk = true;
                profileCount            = 5;
                for (int i = 0; i < profileCount; i++)
                {
                    ProtocolClient profileClient = new ProtocolClient();
                    profileClient.InitializeRandomProfile(profileIndex, testImageData);
                    profileIndex++;

                    if (!await profileClient.RegisterAndInitializeProfileAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], (int)rolePorts[ServerRoleType.ClCustomer]))
                    {
                        profileClient.Dispose();
                        profileInitializationOk = false;
                        break;
                    }

                    TestProfiles.Add(profileClient.Profile.Name, profileClient);
                }

                bool step3Ok = profileInitializationOk;

                log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED");



                // Step 4
                log.Trace("Step 4");

                await client2.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.SrNeighbor], true);

                verifyIdentityOk = await client2.VerifyIdentityAsync();

                // Start neighborhood initialization process.
                requestMessage = mb1.CreateStartNeighborhoodInitializationRequest((uint)profileServer.PrimaryPort, (uint)profileServer.ServerNeighborPort);
                await client2.SendMessageAsync(requestMessage);

                responseMessage = await client2.ReceiveMessageAsync();

                idOk     = responseMessage.Id == requestMessage.Id;
                statusOk = responseMessage.Response.Status == Status.ErrorAlreadyExists;
                startNeighborhoodInitializationOk = idOk && statusOk;

                client2.CloseConnection();

                bool step4Ok = verifyIdentityOk && startNeighborhoodInitializationOk;

                log.Trace("Step 4: {0}", step4Ok ? "PASSED" : "FAILED");


                // Step 5
                log.Trace("Step 5");

                clientResponseMessage = mb1.CreateFinishNeighborhoodInitializationResponse(serverRequestMessage);
                await client1.SendMessageAsync(clientResponseMessage);

                client1.CloseConnection();

                await Task.Delay(20000);

                bool step5Ok = !error;

                log.Trace("Step 5: {0}", step5Ok ? "PASSED" : "FAILED");


                // Step 6
                log.Trace("Step 6");

                // Meanwhile we expect updates to arrive on our simulated profile server.
                error = false;
                List <IncomingServerMessage> psMessages = profileServer.GetMessageList();
                foreach (IncomingServerMessage ism in psMessages)
                {
                    if (ism.Role != ServerRole.ServerNeighbor)
                    {
                        continue;
                    }
                    Message message = ism.IncomingMessage;

                    if ((message.MessageTypeCase == Message.MessageTypeOneofCase.Request) &&
                        (message.Request.ConversationTypeCase == Request.ConversationTypeOneofCase.ConversationRequest) &&
                        (message.Request.ConversationRequest.RequestTypeCase == ConversationRequest.RequestTypeOneofCase.NeighborhoodSharedProfileUpdate))
                    {
                        foreach (SharedProfileUpdateItem updateItem in message.Request.ConversationRequest.NeighborhoodSharedProfileUpdate.Items)
                        {
                            if (updateItem.ActionTypeCase == SharedProfileUpdateItem.ActionTypeOneofCase.Add)
                            {
                                SharedProfileAddItem addItem = updateItem.Add;
                                receivedItems.Add(addItem);
                                log.Trace("Received profile name '{0}'.", updateItem.Add.Name);
                            }
                            else
                            {
                                log.Trace("Received invalid update action type {0}.", updateItem.ActionTypeCase);
                                error = true;
                                break;
                            }
                        }
                    }

                    if (error)
                    {
                        break;
                    }
                }


                bool receivedUpdatesOk = !error;
                bool profilesOk        = client1.CheckProfileListMatchAddItems(TestProfiles, receivedItems);
                bool step6Ok           = receivedUpdatesOk && profilesOk;

                log.Trace("Step 6: {0}", step6Ok ? "PASSED" : "FAILED");


                Passed = step1Ok && step2Ok && step3Ok && step4Ok && step5Ok && step6Ok;

                res = true;
            }
            catch (Exception e)
            {
                log.Error("Exception occurred: {0}", e.ToString());
            }
            client1.Dispose();
            client2.Dispose();

            foreach (ProtocolClient protocolClient in TestProfiles.Values)
            {
                protocolClient.Dispose();
            }

            if (profileServer != null)
            {
                profileServer.Shutdown();
            }

            log.Trace("(-):{0}", res);
            return(res);
        }
Beispiel #26
0
        /// <summary>
        /// Implementation of the test itself.
        /// </summary>
        /// <returns>true if the test passes, false otherwise.</returns>
        public override async Task <bool> RunAsync()
        {
            IPAddress ServerIp    = (IPAddress)ArgumentValues["Server IP"];
            int       PrimaryPort = (int)ArgumentValues["primary Port"];
            int       BasePort    = (int)ArgumentValues["Base Port"];
            int       LocPort     = (int)ArgumentValues["LOC Port"];

            log.Trace("(ServerIp:'{0}',PrimaryPort:{1},BasePort:{2},LocPort:{3})", ServerIp, PrimaryPort, BasePort, LocPort);

            bool res = false;

            Passed = false;

            ProtocolClient client        = new ProtocolClient();
            ProfileServer  profileServer = null;
            LocServer      locServer     = null;

            try
            {
                MessageBuilder mb = client.MessageBuilder;

                // Step 1
                log.Trace("Step 1");

                // Get port list.
                await client.ConnectAsync(ServerIp, PrimaryPort, false);

                Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>();
                bool listPortsOk = await client.ListServerPorts(rolePorts);

                client.CloseConnection();

                // Create identities.
                int    profileNumber = 0;
                byte[] imageData     = File.ReadAllBytes(Path.Combine("images", TestName + ".png"));

                for (int i = 0; i < 20500; i++)
                {
                    ProtocolClient profileClient = new ProtocolClient();
                    profileClient.InitializeRandomProfile(profileNumber, imageData);
                    profileNumber++;
                    TestProfiles.Add(profileClient.Profile.Name, profileClient);
                }


                // Start simulated profile server.
                profileServer = new ProfileServer("TestProfileServer", ServerIp, BasePort, client.GetIdentityKeys(), new GpsLocation(1, 2));
                bool profileServerStartOk = profileServer.Start();

                // Start simulated LOC server.
                locServer = new LocServer("TestLocServer", ServerIp, LocPort);
                bool locServerStartOk = locServer.Start();

                await locServer.WaitForProfileServerConnectionAsync();

                bool step1Ok = profileServerStartOk && locServerStartOk;
                log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");


                // Step 2
                log.Trace("Step 2");

                // Announce new neighbor.
                Iop.Locnet.NeighbourhoodChange change = new Iop.Locnet.NeighbourhoodChange()
                {
                    AddedNodeInfo = profileServer.GetNodeInfo(LocPort)
                };

                bool changeNotificationOk = await locServer.SendChangeNotification(change);

                // Wait for start of neighborhood initialization process.
                IncomingServerMessage incomingServerMessage = await profileServer.WaitForConversationRequest(ServerRole.ServerNeighbor, ConversationRequest.RequestTypeOneofCase.StartNeighborhoodInitialization);


                // Send update.
                bool statusOk     = false;
                bool updateOk     = true;
                int  profilesSent = 0;
                List <ProtocolClient> profilesToSend = new List <ProtocolClient>(TestProfiles.Values);
                while (profilesToSend.Count > 0)
                {
                    int batchSize = Math.Min(Rng.Next(100, 150), profilesToSend.Count);

                    List <SharedProfileUpdateItem> updateItems = new List <SharedProfileUpdateItem>();
                    foreach (ProtocolClient pc in profilesToSend.GetRange(0, batchSize))
                    {
                        updateItems.Add(pc.GetSharedProfileUpdateAddItem());
                    }

                    profilesToSend.RemoveRange(0, batchSize);

                    Message updateRequest = await profileServer.SendNeighborhoodSharedProfileUpdateRequest(incomingServerMessage.Client, updateItems);

                    profilesSent         += batchSize;
                    incomingServerMessage = await profileServer.WaitForResponse(ServerRole.ServerNeighbor, updateRequest);

                    if (profilesSent <= 20000)
                    {
                        statusOk = incomingServerMessage.IncomingMessage.Response.Status == Status.Ok;
                        bool batchOk = (updateRequest != null) && statusOk;
                        if (!batchOk)
                        {
                            updateOk = false;
                            break;
                        }
                    }
                    else
                    {
                        statusOk = incomingServerMessage.IncomingMessage.Response.Status == Status.ErrorInvalidValue;
                        int    badIndex        = 20000 - (profilesSent - batchSize);
                        string expectedDetails = badIndex.ToString() + ".add";
                        log.Trace("Expected details are '{0}'.", expectedDetails);

                        bool detailsOk = incomingServerMessage.IncomingMessage.Response.Details == expectedDetails;
                        bool batchOk   = (updateRequest != null) && statusOk && detailsOk;

                        if (!batchOk)
                        {
                            updateOk = false;
                        }

                        break;
                    }
                }


                bool step2Ok = changeNotificationOk && updateOk;
                log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");



                // Step 3
                log.Trace("Step 3");

                // Start conversation.
                await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);

                bool startConversationOk = await client.StartConversationAsync();

                HashSet <byte[]> expectedCoveredServers = new HashSet <byte[]>(StructuralEqualityComparer <byte[]> .Default)
                {
                    client.GetIdentityId(), Crypto.Sha256(client.ServerKey)
                };

                // Search all profiles.
                Message requestMessage = mb.CreateProfileSearchRequest(null, null, null, null, 0, 100, 100);
                await client.SendMessageAsync(requestMessage);

                Message responseMessage = await client.ReceiveMessageAsync();

                bool idOk = responseMessage.Id == requestMessage.Id;
                statusOk = responseMessage.Response.Status == Status.Ok;


                bool totalRecordCountOk       = responseMessage.Response.ConversationResponse.ProfileSearch.TotalRecordCount == 0;
                bool maxResponseRecordCountOk = responseMessage.Response.ConversationResponse.ProfileSearch.MaxResponseRecordCount == 100;
                bool profilesCountOk          = responseMessage.Response.ConversationResponse.ProfileSearch.Profiles.Count == 0;

                bool queryOk = idOk && statusOk && totalRecordCountOk && maxResponseRecordCountOk && profilesCountOk;

                // Step 3 Acceptance
                bool step3Ok = startConversationOk && queryOk;

                log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED");


                Passed = step1Ok && step2Ok && step3Ok;

                res = true;
            }
            catch (Exception e)
            {
                log.Error("Exception occurred: {0}", e.ToString());
            }
            client.Dispose();

            foreach (ProtocolClient protocolClient in TestProfiles.Values)
            {
                protocolClient.Dispose();
            }

            if (profileServer != null)
            {
                profileServer.Shutdown();
            }
            if (locServer != null)
            {
                locServer.Shutdown();
            }

            log.Trace("(-):{0}", res);
            return(res);
        }
Beispiel #27
0
        /// <summary>
        /// Implementation of the test itself.
        /// </summary>
        /// <returns>true if the test passes, false otherwise.</returns>
        public override async Task <bool> RunAsync()
        {
            IPAddress ServerIp    = (IPAddress)ArgumentValues["Server IP"];
            int       PrimaryPort = (int)ArgumentValues["primary Port"];
            int       BasePort    = (int)ArgumentValues["Base Port"];
            int       LocPort     = (int)ArgumentValues["LOC Port"];

            log.Trace("(ServerIp:'{0}',PrimaryPort:{1},BasePort:{2},LocPort:{3})", ServerIp, PrimaryPort, BasePort, LocPort);

            bool res = false;

            Passed = false;

            ProtocolClient client        = new ProtocolClient();
            ProfileServer  profileServer = null;
            LocServer      locServer     = null;

            try
            {
                MessageBuilder mb = client.MessageBuilder;

                // Step 1
                log.Trace("Step 1");

                profileServer = new ProfileServer("TestProfileServer", ServerIp, BasePort, client.GetIdentityKeys(), new ProfileServerProtocol.GpsLocation(1, 2));
                bool profileServerStartOk = profileServer.Start();


                locServer = new LocServer("TestLocServer", ServerIp, LocPort);
                bool locServerStartOk = locServer.Start();

                await locServer.WaitForProfileServerConnectionAsync();

                bool step1Ok = profileServerStartOk && locServerStartOk;
                log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");


                // Step 2
                log.Trace("Step 2");

                NeighbourhoodChange change = new NeighbourhoodChange()
                {
                    AddedNodeInfo = profileServer.GetNodeInfo(LocPort)
                };

                bool changeNotificationOk = await locServer.SendChangeNotification(change);

                IncomingServerMessage incomingServerMessage = await profileServer.WaitForConversationRequest(ServerRole.ServerNeighbor, ConversationRequest.RequestTypeOneofCase.StartNeighborhoodInitialization);

                Iop.Profileserver.Message finishRequest = await profileServer.SendFinishNeighborhoodInitializationRequest(incomingServerMessage.Client);

                incomingServerMessage = await profileServer.WaitForResponse(ServerRole.ServerNeighbor, finishRequest);

                bool statusOk = incomingServerMessage.IncomingMessage.Response.Status == Iop.Profileserver.Status.Ok;

                bool step2Ok = changeNotificationOk && (finishRequest != null) && statusOk;
                log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");


                Passed = step1Ok && step2Ok;

                res = true;
            }
            catch (Exception e)
            {
                log.Error("Exception occurred: {0}", e.ToString());
            }
            client.Dispose();

            foreach (ProtocolClient protocolClient in TestProfiles.Values)
            {
                protocolClient.Dispose();
            }

            if (profileServer != null)
            {
                profileServer.Shutdown();
            }
            if (locServer != null)
            {
                locServer.Shutdown();
            }

            log.Trace("(-):{0}", res);
            return(res);
        }
Beispiel #28
0
        /// <summary>
        /// Implementation of the test itself.
        /// </summary>
        /// <returns>true if the test passes, false otherwise.</returns>
        public override async Task <bool> RunAsync()
        {
            IPAddress ServerIp    = (IPAddress)ArgumentValues["Server IP"];
            int       PrimaryPort = (int)ArgumentValues["primary Port"];
            int       BasePort    = (int)ArgumentValues["Base Port"];
            int       LocPort     = (int)ArgumentValues["LOC Port"];

            log.Trace("(ServerIp:'{0}',PrimaryPort:{1},BasePort:{2},LocPort:{3})", ServerIp, PrimaryPort, BasePort, LocPort);

            bool res = false;

            Passed = false;

            ProtocolClient client        = new ProtocolClient();
            ProfileServer  profileServer = null;
            LocServer      locServer     = null;

            try
            {
                MessageBuilder mb = client.MessageBuilder;

                // Step 1
                log.Trace("Step 1");

                // Get port list.
                await client.ConnectAsync(ServerIp, PrimaryPort, false);

                Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>();
                bool listPortsOk = await client.ListServerPorts(rolePorts);

                client.CloseConnection();

                // Create identities.
                ProfilePublicKeys = new List <byte[]>();
                for (int i = 0; i < ProfileNames.Count; i++)
                {
                    ProtocolClient protocolClient = new ProtocolClient();
                    ProfilePublicKeys.Add(protocolClient.GetIdentityKeys().PublicKey);
                    protocolClient.Dispose();
                }


                // Start simulated profile server.
                profileServer = new ProfileServer("TestProfileServer", ServerIp, BasePort, client.GetIdentityKeys(), new GpsLocation(1, 2));
                bool profileServerStartOk = profileServer.Start();

                // Start simulated LOC server.
                locServer = new LocServer("TestLocServer", ServerIp, LocPort);
                bool locServerStartOk = locServer.Start();

                await locServer.WaitForProfileServerConnectionAsync();

                bool step1Ok = profileServerStartOk && locServerStartOk;
                log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");


                // Step 2
                log.Trace("Step 2");

                // Initialize the original set of update messages update.
                List <SharedProfileUpdateItem> originalAddUpdateItems = new List <SharedProfileUpdateItem>();
                for (int i = 0; i < ProfileNames.Count; i++)
                {
                    SharedProfileUpdateItem updateItem = new SharedProfileUpdateItem()
                    {
                        Add = new SharedProfileAddItem()
                        {
                            Version           = SemVer.V100.ToByteString(),
                            Name              = ProfileNames[i],
                            Type              = ProfileTypes[i],
                            ExtraData         = ProfileExtraData[i] != null ? ProfileExtraData[i] : "",
                            Latitude          = ProfileLocations[i].GetLocationTypeLatitude(),
                            Longitude         = ProfileLocations[i].GetLocationTypeLongitude(),
                            IdentityPublicKey = ProtocolHelper.ByteArrayToByteString(ProfilePublicKeys[i]),
                            SetThumbnailImage = ProfileImages[i] != null,
                            ThumbnailImage    = ProtocolHelper.ByteArrayToByteString(ProfileImages[i] != null ? File.ReadAllBytes(ProfileImages[i]) : new byte[0])
                        }
                    };

                    originalAddUpdateItems.Add(updateItem);
                }



                // Neighborhood initialization process.

                // Announce new neighbor.
                Iop.Locnet.NeighbourhoodChange change = new Iop.Locnet.NeighbourhoodChange()
                {
                    AddedNodeInfo = profileServer.GetNodeInfo(LocPort)
                };

                bool addNeighborOk = await locServer.SendChangeNotification(change);


                // Wait for start of neighborhood initialization process.
                IncomingServerMessage incomingServerMessage = await profileServer.WaitForConversationRequest(ServerRole.ServerNeighbor, ConversationRequest.RequestTypeOneofCase.StartNeighborhoodInitialization);

                List <SharedProfileUpdateItem> updateItems = new List <SharedProfileUpdateItem>();
                updateItems.Add(originalAddUpdateItems[0]);
                updateItems.Add(originalAddUpdateItems[1]);
                updateItems.Add(originalAddUpdateItems[5]);
                updateItems.Add(originalAddUpdateItems[6]);

                SharedProfileUpdateItem changeItem0 = new SharedProfileUpdateItem()
                {
                    Change = new SharedProfileChangeItem()
                    {
                        IdentityNetworkId = ProtocolHelper.ByteArrayToByteString(Crypto.Sha256(originalAddUpdateItems[0].Add.IdentityPublicKey.ToByteArray())),
                    }
                };

                SharedProfileUpdateItem changeItem1 = new SharedProfileUpdateItem()
                {
                    Change = new SharedProfileChangeItem()
                    {
                        IdentityNetworkId = ProtocolHelper.ByteArrayToByteString(Crypto.Sha256(originalAddUpdateItems[1].Add.IdentityPublicKey.ToByteArray())),
                        SetName           = true,
                        Name = "X"
                    }
                };

                List <SharedProfileUpdateItem> originalUpdateItems = new List <SharedProfileUpdateItem>();
                originalUpdateItems.Add(changeItem1);
                originalUpdateItems.Add(originalAddUpdateItems[2]);
                originalUpdateItems.Add(originalAddUpdateItems[3]);
                originalUpdateItems.Add(originalAddUpdateItems[4]);

                Message requestMessage = await profileServer.SendNeighborhoodSharedProfileUpdateRequest(incomingServerMessage.Client, updateItems);

                incomingServerMessage = await profileServer.WaitForResponse(ServerRole.ServerNeighbor, requestMessage);

                bool statusOk = incomingServerMessage.IncomingMessage.Response.Status == Status.Ok;
                bool updateOk = statusOk;


                // Finish neighborhood initialization process.
                Message finishRequest = await profileServer.SendFinishNeighborhoodInitializationRequest(incomingServerMessage.Client);

                incomingServerMessage = await profileServer.WaitForResponse(ServerRole.ServerNeighbor, finishRequest);

                statusOk = incomingServerMessage.IncomingMessage.Response.Status == Status.Ok;
                bool finishOk = (finishRequest != null) && statusOk;

                bool step2Ok = addNeighborOk && updateOk && finishOk;
                log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");



                // Step 3
                log.Trace("Step 3");

                await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.SrNeighbor], true);

                bool verifyIdentityOk = await client.VerifyIdentityAsync();

                updateItems                = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1]             = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.Version = ProtocolHelper.ByteArrayToByteString(new byte[] { 1, 0 });

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.version");

                bool step3Ok = verifyIdentityOk && updateOk;
                log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED");


                // Step 4
                log.Trace("Step 4");

                updateItems                = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1]             = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.Version = ProtocolHelper.ByteArrayToByteString(new byte[] { 0, 0, 0 });

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.version");

                bool step4Ok = verifyIdentityOk && updateOk;
                log.Trace("Step 4: {0}", step4Ok ? "PASSED" : "FAILED");


                // Step 5
                log.Trace("Step 5");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.IdentityPublicKey = ProtocolHelper.ByteArrayToByteString(Encoding.UTF8.GetBytes(new string ('a', 300)));

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.identityPublicKey");

                bool step5Ok = updateOk;
                log.Trace("Step 5: {0}", step5Ok ? "PASSED" : "FAILED");


                // Step 6
                log.Trace("Step 6");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.IdentityPublicKey = originalAddUpdateItems[0].Add.IdentityPublicKey;

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.identityPublicKey");

                bool step6Ok = updateOk;
                log.Trace("Step 6: {0}", step6Ok ? "PASSED" : "FAILED");


                // Step 7
                log.Trace("Step 7");

                updateItems             = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1]          = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.Name = new string('a', 70);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.name");

                bool step7Ok = updateOk;
                log.Trace("Step 7: {0}", step7Ok ? "PASSED" : "FAILED");


                // Step 8
                log.Trace("Step 8");

                updateItems             = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1]          = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.Name = new string('ɐ', 50);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.name");

                bool step8Ok = updateOk;
                log.Trace("Step 8: {0}", step8Ok ? "PASSED" : "FAILED");


                // Step 9
                log.Trace("Step 9");

                updateItems             = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1]          = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.Type = new string('a', 70);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.type");

                bool step9Ok = updateOk;
                log.Trace("Step 9: {0}", step9Ok ? "PASSED" : "FAILED");


                // Step 10
                log.Trace("Step 10");

                updateItems             = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1]          = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.Type = new string('ɐ', 50);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.type");

                bool step10Ok = updateOk;
                log.Trace("Step 10: {0}", step10Ok ? "PASSED" : "FAILED");


                // Step 11
                log.Trace("Step 11");

                updateItems             = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1]          = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.Type = "";

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.type");

                bool step11Ok = updateOk;
                log.Trace("Step 11: {0}", step11Ok ? "PASSED" : "FAILED");


                // Step 12
                log.Trace("Step 12");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.SetThumbnailImage = true;
                updateItems[1].Add.ThumbnailImage    = ProtocolHelper.ByteArrayToByteString(new byte[0]);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.thumbnailImage");

                bool step12Ok = updateOk;
                log.Trace("Step 12: {0}", step12Ok ? "PASSED" : "FAILED");


                // Step 13
                log.Trace("Step 13");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.SetThumbnailImage = true;
                updateItems[1].Add.ThumbnailImage    = ProtocolHelper.ByteArrayToByteString(new byte[] { 0, 1, 2 });

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.thumbnailImage");

                bool step13Ok = updateOk;
                log.Trace("Step 13: {0}", step13Ok ? "PASSED" : "FAILED");


                // Step 14
                log.Trace("Step 14");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.Latitude = 987654321;

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.latitude");

                bool step14Ok = updateOk;
                log.Trace("Step 14: {0}", step14Ok ? "PASSED" : "FAILED");


                // Step 15
                log.Trace("Step 15");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.Longitude = 987654321;

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.longitude");

                bool step15Ok = updateOk;
                log.Trace("Step 15: {0}", step15Ok ? "PASSED" : "FAILED");


                // Step 16
                log.Trace("Step 16");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.ExtraData = new string('a', 270);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.extraData");

                bool step16Ok = updateOk;
                log.Trace("Step 16: {0}", step16Ok ? "PASSED" : "FAILED");


                // Step 17
                log.Trace("Step 17");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.ExtraData = new string('ɐ', 150);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.extraData");

                bool step17Ok = updateOk;
                log.Trace("Step 17: {0}", step17Ok ? "PASSED" : "FAILED");


                // Step 18
                log.Trace("Step 18");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem()
                {
                    Change = new SharedProfileChangeItem()
                    {
                        IdentityNetworkId = ProtocolHelper.ByteArrayToByteString(Crypto.Sha256(originalAddUpdateItems[0].Add.IdentityPublicKey.ToByteArray())),
                    }
                };

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.set*");

                bool step18Ok = updateOk;
                log.Trace("Step 18: {0}", step18Ok ? "PASSED" : "FAILED");



                // Step 19
                log.Trace("Step 19");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem()
                {
                    Change = new SharedProfileChangeItem()
                    {
                        IdentityNetworkId = ProtocolHelper.ByteArrayToByteString(new byte[] { 0, 1, 2 }),
                        SetName           = true,
                        Name = "X"
                    }
                };

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.identityNetworkId");

                bool step19Ok = updateOk;
                log.Trace("Step 19: {0}", step19Ok ? "PASSED" : "FAILED");


                // Step 20
                log.Trace("Step 20");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[0] = new SharedProfileUpdateItem()
                {
                    Change = new SharedProfileChangeItem()
                    {
                        IdentityNetworkId = ProtocolHelper.ByteArrayToByteString(Crypto.Sha256(originalAddUpdateItems[0].Add.IdentityPublicKey.ToByteArray())),
                        SetName           = true,
                        Name = "X"
                    }
                };
                updateItems[1] = new SharedProfileUpdateItem()
                {
                    Delete = new SharedProfileDeleteItem()
                    {
                        IdentityNetworkId = ProtocolHelper.ByteArrayToByteString(Crypto.Sha256(originalAddUpdateItems[0].Add.IdentityPublicKey.ToByteArray())),
                    }
                };

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.delete.identityNetworkId");

                bool step20Ok = updateOk;
                log.Trace("Step 20: {0}", step20Ok ? "PASSED" : "FAILED");


                // Step 21
                log.Trace("Step 21");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[0] = new SharedProfileUpdateItem(originalAddUpdateItems[2]);
                updateItems[1] = new SharedProfileUpdateItem()
                {
                    Change = new SharedProfileChangeItem()
                    {
                        IdentityNetworkId = ProtocolHelper.ByteArrayToByteString(Crypto.Sha256(originalAddUpdateItems[2].Add.IdentityPublicKey.ToByteArray())),
                        SetName           = true,
                        Name = "X"
                    }
                };

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.identityNetworkId");

                bool step21Ok = updateOk;
                log.Trace("Step 21: {0}", step21Ok ? "PASSED" : "FAILED");


                // Step 22
                log.Trace("Step 22");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[0] = new SharedProfileUpdateItem()
                {
                    Change = new SharedProfileChangeItem()
                    {
                        IdentityNetworkId = ProtocolHelper.ByteArrayToByteString(Crypto.Sha256(originalAddUpdateItems[2].Add.IdentityPublicKey.ToByteArray())),
                        SetName           = true,
                        Name = "X"
                    }
                };
                updateItems[1] = new SharedProfileUpdateItem(originalAddUpdateItems[2]);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.identityPublicKey");

                bool step22Ok = updateOk;
                log.Trace("Step 22: {0}", step22Ok ? "PASSED" : "FAILED");


                // Step 23
                log.Trace("Step 23");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetVersion = true;
                updateItems[1].Change.Version    = ProtocolHelper.ByteArrayToByteString(new byte[] { 1, 0 });

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.version");

                bool step23Ok = updateOk;
                log.Trace("Step 23: {0}", step23Ok ? "PASSED" : "FAILED");


                // Step 24
                log.Trace("Step 24");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetVersion = true;
                updateItems[1].Change.Version    = ProtocolHelper.ByteArrayToByteString(new byte[] { 0, 0, 0 });

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.version");

                bool step24Ok = updateOk;
                log.Trace("Step 24: {0}", step24Ok ? "PASSED" : "FAILED");


                // Step 25
                log.Trace("Step 25");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetName = true;
                updateItems[1].Change.Name    = new string('a', 70);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.name");

                bool step25Ok = updateOk;
                log.Trace("Step 25: {0}", step25Ok ? "PASSED" : "FAILED");


                // Step 26
                log.Trace("Step 26");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetName = true;
                updateItems[1].Change.Name    = new string('ɐ', 50);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.name");

                bool step26Ok = updateOk;
                log.Trace("Step 26: {0}", step26Ok ? "PASSED" : "FAILED");


                // Step 27
                log.Trace("Step 27");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetThumbnailImage = true;
                updateItems[1].Change.ThumbnailImage    = ProtocolHelper.ByteArrayToByteString(Encoding.UTF8.GetBytes(new string((char)0x40, 6000)));

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.thumbnailImage");

                bool step27Ok = updateOk;
                log.Trace("Step 27: {0}", step27Ok ? "PASSED" : "FAILED");


                // Step 28
                log.Trace("Step 28");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetThumbnailImage = true;
                updateItems[1].Change.ThumbnailImage    = ProtocolHelper.ByteArrayToByteString(new byte[] { 0, 1, 2 });

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.thumbnailImage");

                bool step28Ok = updateOk;
                log.Trace("Step 28: {0}", step28Ok ? "PASSED" : "FAILED");


                // Step 29
                log.Trace("Step 29");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetLocation = true;
                updateItems[1].Change.Latitude    = 987654321;
                updateItems[1].Change.Longitude   = 0;

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.latitude");

                bool step29Ok = updateOk;
                log.Trace("Step 29: {0}", step29Ok ? "PASSED" : "FAILED");


                // Step 30
                log.Trace("Step 30");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetLocation = true;
                updateItems[1].Change.Latitude    = 0;
                updateItems[1].Change.Longitude   = 987654321;

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.longitude");

                bool step30Ok = updateOk;
                log.Trace("Step 30: {0}", step30Ok ? "PASSED" : "FAILED");


                // Step 31
                log.Trace("Step 31");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetExtraData = true;
                updateItems[1].Change.ExtraData    = new string('a', 270);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.extraData");

                bool step31Ok = updateOk;
                log.Trace("Step 31: {0}", step31Ok ? "PASSED" : "FAILED");


                // Step 32
                log.Trace("Step 32");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetExtraData = true;
                updateItems[1].Change.ExtraData    = new string('ɐ', 150);

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.extraData");

                bool step32Ok = updateOk;
                log.Trace("Step 32: {0}", step32Ok ? "PASSED" : "FAILED");


                // Step 33
                log.Trace("Step 33");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem()
                {
                    Delete = new SharedProfileDeleteItem()
                    {
                        IdentityNetworkId = ProtocolHelper.ByteArrayToByteString(new byte[] { 0, 1, 2 })
                    }
                };

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.delete.identityNetworkId");

                bool step33Ok = updateOk;
                log.Trace("Step 33: {0}", step33Ok ? "PASSED" : "FAILED");


                // Step 34
                log.Trace("Step 34");

                updateItems             = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1]          = new SharedProfileUpdateItem(updateItems[1]);
                updateItems[1].Add.Name = "";

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.add.name");

                bool step34Ok = updateOk;
                log.Trace("Step 34: {0}", step34Ok ? "PASSED" : "FAILED");


                // Step 35
                log.Trace("Step 35");

                updateItems    = new List <SharedProfileUpdateItem>(originalUpdateItems);
                updateItems[1] = new SharedProfileUpdateItem(changeItem0);
                updateItems[1].Change.SetName = true;
                updateItems[1].Change.Name    = "";

                updateOk = await PerformNeighborhoodUpdateAsync(updateItems, client, "1.change.name");

                bool step35Ok = updateOk;
                log.Trace("Step 35: {0}", step35Ok ? "PASSED" : "FAILED");


                Passed = step1Ok && step2Ok && step3Ok && step4Ok && step5Ok && step6Ok && step7Ok && step8Ok && step9Ok && step10Ok &&
                         step11Ok && step12Ok && step13Ok && step14Ok && step15Ok && step16Ok && step17Ok && step18Ok && step19Ok && step20Ok &&
                         step21Ok && step22Ok && step23Ok && step24Ok && step25Ok && step26Ok && step27Ok && step28Ok && step29Ok && step30Ok &&
                         step31Ok && step32Ok && step33Ok && step34Ok && step35Ok;

                res = true;
            }
            catch (Exception e)
            {
                log.Error("Exception occurred: {0}", e.ToString());
            }
            client.Dispose();

            if (profileServer != null)
            {
                profileServer.Shutdown();
            }
            if (locServer != null)
            {
                locServer.Shutdown();
            }

            log.Trace("(-):{0}", res);
            return(res);
        }
Beispiel #29
0
        /// <summary>
        /// Implementation of the test itself.
        /// </summary>
        /// <returns>true if the test passes, false otherwise.</returns>
        public override async Task <bool> RunAsync()
        {
            IPAddress ServerIp    = (IPAddress)ArgumentValues["Server IP"];
            int       PrimaryPort = (int)ArgumentValues["primary Port"];
            int       BasePort    = (int)ArgumentValues["Base Port"];
            int       LocPort     = (int)ArgumentValues["LOC Port"];

            log.Trace("(ServerIp:'{0}',PrimaryPort:{1},BasePort:{2},LocPort:{3})", ServerIp, PrimaryPort, BasePort, LocPort);

            bool res = false;

            Passed = false;

            ProtocolClient client        = new ProtocolClient();
            ProfileServer  profileServer = null;
            LocServer      locServer     = null;

            try
            {
                MessageBuilder mb = client.MessageBuilder;

                // Step 1
                log.Trace("Step 1");

                // Get port list.
                await client.ConnectAsync(ServerIp, PrimaryPort, false);

                Dictionary <ServerRoleType, uint> rolePorts = new Dictionary <ServerRoleType, uint>();
                bool listPortsOk = await client.ListServerPorts(rolePorts);

                client.CloseConnection();


                // Radius generation.
                R2 = (uint)Rng.Next(R2Min, R2Max);
                R1 = (uint)Rng.Next(R1Min, (int)(R1R2RatioMax * R2));
                R3 = (uint)Rng.Next((int)(R3R2RatioMax * R2), R3Max);
                log.Trace("R1: {0,8} m", R1);
                log.Trace("R2: {0,8} m", R2);
                log.Trace("R3: {0,8} m", R3);

                // Location generation
                for (int i = 0; i < LocationCount; i++)
                {
                    if (PredefinedLocations.Count > i)
                    {
                        GeneratedLocations.Add(GenerateLocation(PredefinedLocations[i], R2));
                    }
                    else
                    {
                        int lat = Rng.Next((int)(GpsLocation.LatitudeMin * GpsLocation.LocationTypeFactor), (int)(GpsLocation.LatitudeMax * GpsLocation.LocationTypeFactor) + 1);
                        int lon = Rng.Next((int)(GpsLocation.LongitudeMin * GpsLocation.LocationTypeFactor) + 1, (int)(GpsLocation.LongitudeMax * GpsLocation.LocationTypeFactor) + 1);
                        GeneratedLocations.Add(new GpsLocation(lat, lon));
                    }
                }

                log.Trace("Generated locations:");
                for (int i = 0; i < LocationCount; i++)
                {
                    log.Trace(" #{0:00}: {1:US}", i, GeneratedLocations[i]);
                }


                // Create identities.
                int    profileNumber = 0;
                byte[] imageData     = File.ReadAllBytes(Path.Combine("images", TestName + ".png"));

                uint[] rads = new uint[] { R1, R2, R3 };
                for (int locIndex = 0; locIndex < LocationCount; locIndex++)
                {
                    for (uint radIndex = 0; radIndex < rads.Length; radIndex++)
                    {
                        for (int idIndex = 0; idIndex < RadiusIdentityCount; idIndex++)
                        {
                            GpsLocation basePoint = GeneratedLocations[locIndex];
                            uint        radius    = rads[radIndex];
                            GpsLocation location  = GenerateLocation(basePoint, radius);
                            ProfileLocations.Add(location);

                            ProtocolClient profileClient = new ProtocolClient();
                            profileClient.InitializeRandomProfile(profileNumber, imageData);
                            profileNumber++;
                            profileClient.Profile.Location = location;

                            TestProfiles.Add(profileClient.Profile.Name, profileClient);
                            ProfileNames.Add(profileClient.Profile.Name);
                        }
                    }
                }


                // Start simulated profile server.
                profileServer = new ProfileServer("TestProfileServer", ServerIp, BasePort, client.GetIdentityKeys(), new GpsLocation(1, 2));
                bool profileServerStartOk = profileServer.Start();

                // Start simulated LOC server.
                locServer = new LocServer("TestLocServer", ServerIp, LocPort);
                bool locServerStartOk = locServer.Start();

                await locServer.WaitForProfileServerConnectionAsync();

                bool step1Ok = profileServerStartOk && locServerStartOk;
                log.Trace("Step 1: {0}", step1Ok ? "PASSED" : "FAILED");


                // Step 2
                log.Trace("Step 2");

                // Announce new neighbor.
                Iop.Locnet.NeighbourhoodChange change = new Iop.Locnet.NeighbourhoodChange()
                {
                    AddedNodeInfo = profileServer.GetNodeInfo(LocPort)
                };

                bool changeNotificationOk = await locServer.SendChangeNotification(change);

                // Wait for start of neighborhood initialization process.
                IncomingServerMessage incomingServerMessage = await profileServer.WaitForConversationRequest(ServerRole.ServerNeighbor, ConversationRequest.RequestTypeOneofCase.StartNeighborhoodInitialization);


                // Send update.
                bool statusOk = false;
                bool updateOk = true;
                List <ProtocolClient> profilesToSend = new List <ProtocolClient>(TestProfiles.Values);
                while (profilesToSend.Count > 0)
                {
                    int batchSize = Rng.Next(1, Math.Min(100, profilesToSend.Count) + 1);

                    List <SharedProfileUpdateItem> updateItems = new List <SharedProfileUpdateItem>();
                    foreach (ProtocolClient pc in profilesToSend.GetRange(0, batchSize))
                    {
                        updateItems.Add(pc.GetSharedProfileUpdateAddItem());
                    }

                    profilesToSend.RemoveRange(0, batchSize);

                    Message updateRequest = await profileServer.SendNeighborhoodSharedProfileUpdateRequest(incomingServerMessage.Client, updateItems);

                    incomingServerMessage = await profileServer.WaitForResponse(ServerRole.ServerNeighbor, updateRequest);

                    statusOk = incomingServerMessage.IncomingMessage.Response.Status == Status.Ok;
                    bool batchOk = (updateRequest != null) && statusOk;
                    if (!batchOk)
                    {
                        updateOk = false;
                        break;
                    }
                }


                // Finish neighborhood initialization process.
                Message finishRequest = await profileServer.SendFinishNeighborhoodInitializationRequest(incomingServerMessage.Client);

                incomingServerMessage = await profileServer.WaitForResponse(ServerRole.ServerNeighbor, finishRequest);

                statusOk = incomingServerMessage.IncomingMessage.Response.Status == Status.Ok;
                bool finishOk = (finishRequest != null) && statusOk;


                bool step2Ok = changeNotificationOk && updateOk && finishOk;
                log.Trace("Step 2: {0}", step2Ok ? "PASSED" : "FAILED");



                // Step 3
                log.Trace("Step 3");

                // Start conversation.
                await client.ConnectAsync(ServerIp, (int)rolePorts[ServerRoleType.ClNonCustomer], true);

                bool startConversationOk = await client.StartConversationAsync();

                HashSet <byte[]> expectedCoveredServers = new HashSet <byte[]>(StructuralEqualityComparer <byte[]> .Default)
                {
                    client.GetIdentityId(), Crypto.Sha256(client.ServerKey)
                };

                // Search all profiles.
                Message requestMessage = mb.CreateProfileSearchRequest(null, null, null, null, 0, 1000, 1000, false, false);
                await client.SendMessageAsync(requestMessage);

                Message responseMessage = await client.ReceiveMessageAsync();

                bool idOk = responseMessage.Id == requestMessage.Id;
                statusOk = responseMessage.Response.Status == Status.Ok;


                bool totalRecordCountOk       = responseMessage.Response.ConversationResponse.ProfileSearch.TotalRecordCount == ProfileNames.Count;
                bool maxResponseRecordCountOk = responseMessage.Response.ConversationResponse.ProfileSearch.MaxResponseRecordCount == 1000;
                bool profilesCountOk          = responseMessage.Response.ConversationResponse.ProfileSearch.Profiles.Count == ProfileNames.Count;

                HashSet <byte[]> realCoveredServers = new HashSet <byte[]>(StructuralEqualityComparer <byte[]> .Default);
                foreach (ByteString csId in responseMessage.Response.ConversationResponse.ProfileSearch.CoveredServers)
                {
                    realCoveredServers.Add(csId.ToByteArray());
                }
                bool coveredServersOk = expectedCoveredServers.SetEquals(realCoveredServers);


                bool queryRespOk = idOk && statusOk && totalRecordCountOk && maxResponseRecordCountOk && profilesCountOk;
                bool resultsOk   = client.CheckProfileListMatchSearchResultItems(TestProfiles, responseMessage.Response.ConversationResponse.ProfileSearch.Profiles.ToList(), false, false, client.GetIdentityId(), false);

                bool query1Ok = queryRespOk && resultsOk;

                bool queriesOk = true;
                // Search queries around target locations.
                for (int locIndex = 0; locIndex < LocationCount; locIndex++)
                {
                    for (uint radIndex = 0; radIndex < rads.Length + 1; radIndex++)
                    {
                        uint        radius         = radIndex < rads.Length ? rads[radIndex] : (uint)Rng.Next(1000000, 10000000);
                        GpsLocation targetLocation = GeneratedLocations[locIndex];
                        requestMessage = mb.CreateProfileSearchRequest(null, null, null, targetLocation, radius, 1000, 1000, false, false);
                        await client.SendMessageAsync(requestMessage);

                        responseMessage = await client.ReceiveMessageAsync();

                        idOk     = responseMessage.Id == requestMessage.Id;
                        statusOk = responseMessage.Response.Status == Status.Ok;

                        Dictionary <string, ProtocolClient> expectedClients = GetClientsInLocation(targetLocation, radius);
                        totalRecordCountOk       = responseMessage.Response.ConversationResponse.ProfileSearch.TotalRecordCount == expectedClients.Count;
                        maxResponseRecordCountOk = responseMessage.Response.ConversationResponse.ProfileSearch.MaxResponseRecordCount == 1000;
                        profilesCountOk          = responseMessage.Response.ConversationResponse.ProfileSearch.Profiles.Count == expectedClients.Count;

                        queryRespOk = idOk && statusOk && totalRecordCountOk && maxResponseRecordCountOk && profilesCountOk;
                        resultsOk   = client.CheckProfileListMatchSearchResultItems(expectedClients, responseMessage.Response.ConversationResponse.ProfileSearch.Profiles.ToList(), false, false, client.GetIdentityId(), false);

                        queriesOk = queryRespOk && resultsOk;
                        if (!queriesOk)
                        {
                            log.Trace("Search query location {0} with radius {1} should produce {2} profiles, but produced {3} profiles.", targetLocation, radius, expectedClients.Count, responseMessage.Response.ConversationResponse.ProfileSearch.Profiles.Count);
                            log.Trace("Expected names list:");
                            foreach (string name in expectedClients.Keys)
                            {
                                log.Trace("  {0}", name);
                            }

                            List <string> resultNames = responseMessage.Response.ConversationResponse.ProfileSearch.Profiles.Select(r => r.Name).OrderBy(r => r).ToList();
                            log.Trace("Query result names list:");
                            foreach (string name in resultNames)
                            {
                                log.Trace("  {0}", name);
                            }
                            break;
                        }

                        log.Trace("Search query location {0} with radius {1} produced {2} correct profiles.", targetLocation, radius, expectedClients.Count);
                    }

                    if (!queriesOk)
                    {
                        break;
                    }
                }

                // Step 3 Acceptance
                bool step3Ok = startConversationOk && query1Ok && queriesOk;

                log.Trace("Step 3: {0}", step3Ok ? "PASSED" : "FAILED");


                Passed = step1Ok && step2Ok && step3Ok;

                res = true;
            }
            catch (Exception e)
            {
                log.Error("Exception occurred: {0}", e.ToString());
            }
            client.Dispose();

            foreach (ProtocolClient protocolClient in TestProfiles.Values)
            {
                protocolClient.Dispose();
            }

            if (profileServer != null)
            {
                profileServer.Shutdown();
            }
            if (locServer != null)
            {
                locServer.Shutdown();
            }

            log.Trace("(-):{0}", res);
            return(res);
        }
Beispiel #30
0
 public void Parse_Null()
 {
     Assert.Throws <ArgumentNullException>(() => ProfileServer.ParseSecretName(null));
 }